Bonjour à tous, afin d’être le plus concis possible, je vais exposer ma problématique via un cas concret.
INTRODUCTION
L’option de protection contre les pertes qu’offre le brooker que j’utilise est le : STOP SUIVEUR (en % du dernier plus haut), exemple :
- achat prix/action = 10€, Stop = 10%, Seuil de protection intial = 9€
- plus tard, l’action fera un plus haut (mèche) à 15€, seuil réajusté = 13,50€
- au prochain plus haut = 20€, Seuil sera réajusté à 18€
GROS DEFAUT
Le gros défaut de ce système de protection est que toute mèche représentant un plus bas, peut facilement venir clôturer notre position, alors même que la tendance aurait été fortement haussière. Dans l’exemple précédent, une mèche à 17,90€ vendrait l’action. A moins de mettre un % très élevé, dans ce cas, le rôle de Stop Loss ne serait plus très bien assuré.
L’OBJECTIF
J’aimerais écrire un programme qui pour une action donnée sur une période donnée (ex: 6 mois) m’aide à rapidement visualiser le % de variation entre les plus hauts et plus bas successifs.
LE PROGRAMME
- Commencer à une date donnée (ex: 20200801)
- Trouver le prochain plus haut (ex: 10€)
- Trouver le prochain plus bas (ex: 8€)
- Calculer la variation (ex: 20%)
- Dés qu’un prochain plus haut est atteint on recommence tout.Cela pourrait ainsi donner :
Nouveau plus haut : 15€
Nouveau plus bas : 9€
Variation : 40%
- La sortie de ce programme afficherait donc une courbe indiquant : 20, puis 40.
REMARQUES :
- Un nouveau plus haut, est par définition, plus haut que le précédent plus haut.
- Dès qu’il y a nouveau plus haut, le précédent plus bas n’est plus valide.
- Bien sûr, si plus aucun nouveau plus haut trouvé, la sortie restera ainsi : 20, 40.
- Cependant, si le programme devait boucler de nouveau, suite un nouveau plus haut, cela donnerait :
- Nouveau plus haut : 16€
- Nouveau plus bas : 12€
- Variation : 25%
- La sortie serait : 20, 40, 25.
MES TENTATIVES
- Pour détecter le plus haut j’ai écrit :
i = 10
mini = low[i]
maxi = high[i]
while i > 0 do
i = i - 1
if high[i] > high[i-1] then
maxi = high[i]
if low[i] < low[i-1] then
mini = low [i]
var = (maxi/mini-1)*100
continue
endif
endif
break
wend
return var
- Rien que là, plusieurs problèmes :
- Le programme calcule la sortie pour les valeurs du graphique.
- Je ne sais pas lui dire de ne calculer que pour les valeurs après une date donnée.
- J’avais essayé de borner cela à 10 périodes grâce à mon compteur, mais il calcule pour toutes les valeurs quand-même.
- Ce programme affiche des plus hauts qui parfois, sont plus bas que le précédent (voir IMAGE_1 ci-jointe).
- Pour détecter le plus bas, j’ai utilisé le même principe de code, mais cela fonctionne encore moins bien.
- J’ai également essayé d’utiliser les commandes :
- RANGE : mais ça ne répond pas à mon besion qui cherche à regarder le plus haut vs plus bas des chandeliers suivants et non-pas plus vs plus-bas du même chanderlier.
- DATE: j’ai tenté la commande if date > 20200801, pour éviter que le calcule ne se fasse pour toutes les valeurs du graphique, mais uniquement entre le 01er Août 2020 et aujoud’hui… en vain.
CONCLUSION
Merci par avance pour votre support, j’ai tenté de nombreuses solutions, mais pour le moment j’ai passé des heures à m’arracher les cheveux.
Bonjour, une façon de faire sans boucle (donc économisant du temps de calcul), et en progressant en temps réel sans besoin de revenir en arrière (donc ne profitant pas de “connaitre le futur” pour faire les calculs à un point passé quelqconque) pourrait être ainsi:
startdate=20210203
if opendate>=startdate then
if high>hh then
hh=high
refll=hh
res1=0
endif
if high<hh then
refll=min(refll, low)
res1=(hh-refll)/hh*100
endif
endif
if res1<res1[1] then
res2=res1[1]
endif
//return hh, refll
return res1,0,res2
startdate y étant la date de départ souhaitée au format YYYYMMDD
hh le plus haut qui s’actualise,
refll la progression du nouveau plus bas de référence à partir du plus haut le plus récent,
res1 (résultat 1) le pourcentage de baisse actualisé chaque fois que le plus bas descend, et remis à 0 quand un nouveau plus haut se forme,
et j’ai ajouté res2 la visualisation simplifiée de l’amplitude max atteinte par res1 si on ne veut voir que l’extrême et pas toute la progression.
Tu as pensé à l’écart type sinon ?
Bonjour,
Merci pour ce rapide retour et les explications des différentes variables.
A commencer par le moyen de borner les calculs à une période donnée, finalement très simple, mais très utile :
startdate=20210203
if opendate>=startdate then
Je n’ai cependant pas encore saisi toutes les autres subtilités, mais j’y travaille.
Je ne connais notamment pas cette syntaxe, où l’on affecte deux paramètres à min : refll=min(refll, low)
Les débuts sont toujours un peu laborieux, mais je trouve qu’avec ce language il faut parfois sortir un canon pour tuer une mouche… !
Par exemple, lui faire afficher quelque chose d’extra simple : la clôture maximum de l’année 2019… une syntaxe telle que : highest[2019](close), aurait été tellement la bienvenue !
Hélas non, il faut plusieurs variables, boucles, etc., etc., avant d’espèrer arriver au bon résultat… et encore même pas, car le code ci-dessous en fonctionne pas…
startdate = 20190101
enddate = 20191231
c1 = opendate > startdate
c2 = opendate < enddate
if c1 and c2 then
v1 = highest[52](close)
endif
return v1
Bonjour,
Cependant, étant encore un peu trop débutant, hélas ce commentaire trop succinct ne va pas beaucoup m’aider dans l’immédiat.
Mais merci quand-même pour ce retour, je creuserai à l’avenir.
En complément, cela aidera certainement à mieux cerner mes incompréhensions…
De ce que j’avais compris le close[1] devait renvoyer à l’avant dernier chandelier affiché, close[2] à l’avant-avant dernier chandelier affiché.
Autrement dit, si nous sommes en graphique journalier, et que nous étions le 10 du mois, close[1] devrait donner le prix de fermeture de la veille (le 09 du mois), close[2] d’avant-hier (le 08 du mois), close[5] de 5 jours auparavant, donc du 05 du mois.
Après une multitude de tentatives, voilà qu’il est maintenant 03h30 du matin passé, hélas, le tout se solde sur des échecs, ce n’est pas faute d’avoir essayé… C’est assez pénible que de constater que la toute simple et dernière tentative que je fais ne renvoie pas non-plus le résultat attendu.
c1 = close[1]
return c1
Je demande la fermeture d’hier, en sortie je m’attend à un trait unique indiquant 40,98 ! et là, un graphique complet est affiché (cf. pièce jointe: Fermeture_de_la_veille.jpg)…
Encore merci à vous pour le support.
Sur ce dernier exemple, ton code est correct, tu retournes la valeur de la bougie n-1 à chaque bougie. Ton code est aussi lu et calculé dans l’historique, donc la valeur que tu affectes à c1 également.
Si tu veux tracer un élément graphique comme une ligne droite, utilises DRAWHLINE
drawhline(c1)
Si tu débutes en programmation, je te suggère les formations vidéos du site: Premiers pas avec la programmation pour ProRealTime
Le code complet pour ne tracer qu’une seule ligne serait donc :
defparam drawonlastbaronly=true
c1 = close[1]
drawhline(c1)
return
Bonjour,
Merci pour le lien.
Même si j’ai déjà revu le doc. “probuilder_c1486047630c.pdf“, je pense que je ferai la formation guidée également.
Re-bonjour,
Sur le principe, on demande au programme la valeur de clôture de la veille, je ne comprends pas pourquoi la sortie n’est pas uniquement une seule valeur…
c1 = close[1]
La côture de la veille, c’est en effet une seule et unique valeur, valeur de clôture de l’avant-dernier chandelier le plus à droite sur le graphique. Saurais-tu aider à comprendre pourquoi PRT trace une graphique pour toutes les valeurs svp ?
Concernant le programme, j’ai essayé, mais ça ne semble pas fonctionner (cf. Fermeture_de_la_veille_02.jpg).
La valeur entre crochet représente la quantité de bougie en arrière pour récupérer une valeur du passé. Donc Close[1] n’est pas le cours de la clôture de la veille au sens strict, mais celui de la bougie n-1 (peu importe l’UT), et cela peu importe où tu te trouves dans l’historique.
Prenons un exemple, si dans ton programme, tu aurais voulu tester “la clôture de la veille”, mais uniquement les Mardi, comment aurais-tu fait, si tu ne pouvais aller chercher dans les constantes de prix le Close du n-1 ?
Pour l’indicateur, tu ne vois rien car l’échelle ne s’adapte pas automatiquement aux “dessins” réalisés par les instructions graphiques. Dans le cas présent, tu dois remplacer la dernière ligne par celle-ci (on retourne la valeur de c1, mais on la cache avec une transparence totale)
return c1 coloured(100,100,100,0)
Bien noté pour la notion close[1], ça ne signifie pas le n-1 par rapport à la dernière bougie sur le graphique, mais le n-1 quel qu’il soit.
Au-delà de la notion graphique, ici si j’essayais d’otenir une valeur unique (une droite) en sortie, mon réel objectif était d’ajouter un nouveau paramètre à un de mes screeners.
Je voulais que ce screener, me liste les actions qui dans les 4 années passées, avaient eu un plus haut à 4x fois le cours actuel.
Difficile de mettre une condition telle que : (if A => B * 4 then) si je n’arrive pas à obtenir une constante pour A…
Merci.
Le cours actuel est Close[0]
Si tu écris une condition comme un booléen:
maCondition = Close[0] > plushaut
screener[maCondition]
alors cette variable retournera 0 (faux) ou 1 (vrai) à chaque bougie, mais le screener lui attendra la fin de la lecture de l’historique pour t’informer, et donc la bougie courante.