Overblog Suivre ce blog
Administration Créer mon blog
16 janvier 2010 6 16 /01 /janvier /2010 15:22

Lissage : Encore & Toujours.

Pour la détection des cycles, la technique idéale est l'emploi d'une moyenne centrée.  L'idée, au départ, serait d'utiliser un filtre sans lag et de le reporter sur l'UT supérieure.  On réduirait ainsi le lag pour arriver à un moyenne "quasi centrée".
Pour filtrer les cours et diminuer le lag, j'ai essayé d'extrapoler la prochaine valeur puis j'ai appliqué un filtre avec lag à cette valeur.  Donc, si le lag est d'une barre, comme j'extrapole le cours à j+1,au final la courbe devrait être centrée ?
Ci-dessous, une vue d'OXY avec l'indicateur en vert/rouge.  Le filtre a l'air correct et finalement, se rapproche d'une moyenne de Hull de période 6 (en bleu).

hk182

J'ai repris la même procédure sur l'UT supérieure mais je dois passer par un lissage supplémentaire et j'ai, donc, de nouveau un petit lag.  Je pense qu'en refaisant une nouvelle extrapolation, ça devrait être OK mais PRT supportera-t-il ?
Ci-dessous, la vue avec le filtre de degré supérieur en jaune :

hk183.gif

Avec une autre application : le lag est un peu moins important, aux alentours de 2 barres....... 
Je vais donc essayer la double extrapolation.  A suivre.

hk184.gif

Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
16 avril 2009 4 16 /04 /avril /2009 20:19

RSI Chandeliers.


Voici à la demande de Mallory, le RSI en représentation chandeliers.  L'indicateur est calculé sur la cloture des barres précédentes et sur les données intra-barre de la dernière bougie.  Une vue de l'indicateur (14) appliqué à GOOG en daily :



Il faut bien sûr créer 3 indicateurs : bas, haut et corps.  Mettre également p en variable : longueur du RSI.
Et les codes pour Proréaltime :

//////////// rsi chandelier bas ////////////////
hausse=max(0,close-close[1])
baisse=max(0,close[1]-close)
mh=wilderaverage[p](hausse)
mb=wilderaverage[p](baisse)
rs=mh/mb
rsii=100-100/(1+rs)
hauss=max(0,open-close[1])
baiss=max(0,close[1]-open)
testh=(mh[1]*(p-1)+hauss)/p
testb=(mb[1]*(p-1)+baiss)/p
testrs=testh/testb
testrsi=100-100/(1+testrs)
hauss1=max(0,low-close[1])
baiss1=max(0,close[1]-low)
testh1=(mh[1]*(p-1)+hauss1)/p
testb1=(mb[1]*(p-1)+baiss1)/p
testrs1=testh1/testb1
testrsi1=100-100/(1+testrs1)
c2=min(rsii,testrsi)
r=abs(c2-testrsi1)
r=(r)/29
b1=testrsi1
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

///////////// rsi chandelier haut ///////////////
hausse=max(0,close-close[1])
baisse=max(0,close[1]-close)
mh=wilderaverage[p](hausse)
mb=wilderaverage[p](baisse)
rs=mh/mb
rsii=100-100/(1+rs)
hauss=max(0,open-close[1])
baiss=max(0,close[1]-open)
testh=(mh[1]*(p-1)+hauss)/p
testb=(mb[1]*(p-1)+baiss)/p
testrs=testh/testb
testrsi=100-100/(1+testrs)
hauss1=max(0,high-close[1])
baiss1=max(0,close[1]-high)
testh1=(mh[1]*(p-1)+hauss1)/p
testb1=(mb[1]*(p-1)+baiss1)/p
testrs1=testh1/testb1
testrsi1=100-100/(1+testrs1)
c2=max(rsii,testrsi)
r=abs(c2-testrsi1)
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

////////////// rsi chandelier corps ///////////////
hausse=max(0,close-close[1])
baisse=max(0,close[1]-close)
mh=wilderaverage[p](hausse)
mb=wilderaverage[p](baisse)
rs=mh/mb
rsii=100-100/(1+rs)
hauss=max(0,open-close[1])
baiss=max(0,close[1]-open)
testh=(mh[1]*(p-1)+hauss)/p
testb=(mb[1]*(p-1)+baiss)/p
testrs=testh/testb
testrsi=100-100/(1+testrs)
r=abs(testrsi-rsii)
r=(r)/29
if testrsi<rsii then
    b1=testrsi
else
    b1=rsii
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
c=rsii-testrsi
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


Repost 0
Published by hk_lisse - dans Indicateurs
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
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
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
25 septembre 2008 4 25 /09 /septembre /2008 19:13

Le RSI PDF Generator.

Comme demandé par Alvaro, voici le RSI PDF Generator.  Rien de nouveau, en fait, Ehlers le présentait déjà en 2007 (voir séminar).  Le graphe ne représente rien d'autre que la distribution du RSI modifié de Elhers.  Je vous passe l'interprétation qu'il en fait, je ne suis pas convaicu.  Est-ce parce que le RSI passe peu de temps dans la zone 20 que pour autant les cours vont remonter ?

Ici, une vue de la répartition du RSI pour le E-mini SP, 10 années demandées, soit 2975 barres :



Sur Prorealtime, l'axe des abscisses étant dévolu aux dates, j'ai marqué par un trait rouge les différents niveaux du RSI par 10.  Donc la page 21, Alvaro, ne donne pas le code d'un système de trading miracle........
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
31 août 2008 7 31 /08 /août /2008 14:56

La Médiane, un nouvel indicateur magique ?

La Médiane n'est pas disponible par défaut sur Prorealtime.  Cet indicateur reprend la valeur médiane d'un échantillon, CAD tel que 50% des données soient inférieures à sa valeur et bien sûr 50% des données supérieures à cette même valeur.  Normalement, on procède par un tri par ordre croissant de l'échantillon et on prend la donnée de rang (N+1)/2 pour N impair sinon la moyenne des données de rang N/2 et (N/2)+1 pour N pair.

La plateforme Prorealtime ne permettant pas l'usage de tableaux, il est assez fastidieux de programmer de tels tris.  D'autant plus que l'on est toujours à la merci du message d'erreur "boucle sans fin" si on dépasse un certain nombre d'instructions.

Dutchy propose sur le forum Aktienboard.com, un programme qui contourne le problème du tri.  Mais cette version garde comme inconvénients d'être limitée à une longueur de 15 (sinon on a le message d'erreur "boucle sans fin'), d'être approximative dans le cas où plusieurs valeurs de l'échantillon sont égales et de ne fonctionner que pour un paramètre impair.  J'ai amélioré le programme pour les 2 premiers points, reste le problème du paramètrage pair où il faudrait faire tourner le programme deux fois et en extraire la moyenne des 2 sorties, ce qui est trop lourd pour le logiciel.

Pour contourner le problème du nombre d'instructions exécutables (boucle dans une boucle), je crée un sous programme "MEADIAN SUB", dont voici le code (il faut introduire x et len en variables) :

/////////// median sub /////////////////
inf=0
sign=0
egal=0
for p=0 to len-1
    if close[p]<close[x] then
        inf=inf+1
    elsif close[p]=close[x] then
        egal=egal+1
    endif
next
sup=len-inf-egal
if min(inf,sup)+egal>max(inf,sup) then
    sign=1
endif
return sign

Et maintenant le code de l'indicateur lui-même (il faut introduire par en variable, qui représente la longueur de l'échantillon sur laquelle le calcul est effectué) :

///////////////// indicateur médiane /////////////
par=(par mod 2=0)+par
for i=0 to par-1
    my10=call "median sub"[i,par]
    if my10=1 then
        medi=close[i]
        break
    endif
next
if barindex<par then
    medi=undefined
endif
return medi

Et une vue de la Médiane appliquée à l'indice DOW JONES, en bleu de longueur 5 et en blanc de longueur 25 :



Le programme reste lourd pour des paramètrages de valeurs élevées du fait de l'emploi de la subroutine.

Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
7 août 2008 4 07 /08 /août /2008 19:22

L'indicateur Scalper, version II.

Voici une seconde version de l'indicateur Scalper de Carter.  Les règles pour la détermination des points de retournement sont toujours identiques, seul la méthode d'affichage à l'écran diffère.  Ici, les niveaux des points "swing" apparaissent une fois la configuration validée, donc au mieux, 2 barres aprés le sommet ou le creux.  Ci-dessous, une vue du CAC avec l'indicateur dans sa nouvelle version :



Et le code pour Prorealtime :

once scalp=undefined
once scolp=undefined
c1=high<high[1] and high[1]>high[2] and high[1]>high[3] and flag=0
if c1 then
    flag=1
    th=high[1]
    tl=low
endif
if flag=1 and high>th then
    flag=0
endif
if flag=1  and close<tl then
    scalp=th
    flag=0
endif
c2=low>low[1] and low[1]<low[2] and low[1]<low[3] and flog=0
if c2 then
    flog=1
    tth=low[1]
    ttl=high
endif
if flog=1 and low<tth then
    flog=0
endif
if flog=1 and close>ttl then
    scolp=tth
    flog=0
endif
return scalp,scolp

Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article
20 juillet 2008 7 20 /07 /juillet /2008 20:48

L'indicateur Scalper de John Carter.

Toujours issu du livre de John Carter, "Mastering The Trade", voici l'indicateur Scalper.  L'auteur écrit qu'il a observé que les points de retournement du marché se situent souvent après 3 higher high ou 3 lower low.  Il n'en dit pas plus et reste assez vague sur la construction de l'indicateur.  Dans une vidéo de présentation (visible ici), on constate que la construction est un peu différente de celle décrite dans le livre.  J'ai repris cette explication pour sortir un premier programme mais quelques interrogations subsistent, comme vous l'allez voir.

Pour les sommets, le raisonnement est le suivant, il faut :
- high[1]>high[2] et high[1]>high[3] et high[0]<high[1], ce qui marque le possible sommet en high[1].
- pour valider ce possible point de retournement, il suffit d'une cloture sous low[0] sans que high[1] ne soit dépassé, sinon on recommence la procédure.

Les interrogations sont les suivantes :
- les creux et les sommets doivent-ils être obligatoirement en alternance (ce qui n'est pas le cas dans cette version) ?
- ne peut-on pas prendre, dans certains cas, la condition : high[1]>high[2] et high[2]>high[3] afin de filtrer l'indicateur ?

Voici un vue du CAC avec cette première version du Scalper :



Et le code pour Prorealtime :

once rr=1
mb=average[20](typicalprice)
k=48
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
clo1=dpo[n](close)
moyc=close-clo1
clot=(moyc-moyc[1]+(close[p])/n)*n
clot=(round(clot*100))/100
cond1=(high>high[1] and high>high[2])
cond2=(cond1 and high>hi[46]) and (barindex>bari or rr=-1)
if cond1 and cond2 then
    flagg=1
    targeth=high
    targetl=lo[46]
else
    flagg=0
    signa=mb
endif
for zz=0 to 45
    if clot[45-zz]<targetl and hi[45-zz]<=targeth and flagg=1  then
        signa=high+(averagetruerange[20](close))*.5
        rr=1
        bari=barindex+zz+2
        break
    elsif     hi[45-zz]>targeth then
        signa=mb
        break
    endif
next
condi=(low<low[1] and low<low[2]) and low<lo[46] and (barindex>bar or rr=1)
if condi then
    fflag=1
    target1=low
    target2=hi[46]
else
    fflag=0
    siigna=mb
endif
for kk=0 to 45
    if clot[45-kk]>target2 and lo[45-kk]>=target1 and fflag=1 then
        siigna=low-(averagetruerange[20](close))*.5
        rr=-1
        bar=barindex+kk+2
        break
    elsif lo[45-kk]<target1 then
        siigna=mb
        break
    endif
next
if barindex < 100 then
    signa=undefined
    siigna=undefined
endif
return signa,siigna,mb

Ce programme fait appel aux données futures et n'est utilisable qu'en EOD.  Un version temps réel peut en être dérivée.
Repost 0
Published by hk_lisse - dans Indicateurs
commenter cet article