programmer une droite

pour ce rendre conte des erreurs il n'y a pas besoin d'êtres un géni, il suffit d'essayer les programmes présent dans le manuel probuilder.
sur le manuel probuilder il y a un programme a la p18 qui affiche un message d'erreurs :

Boucle conditionnelle WHILE a la p18
Voici ci-après un exemple intuitif :

Result = 0
WHILE Close > Average[20](Close) DO
Result = 1
WEND
RETURN Result

ce programme ne fonctionne pas et prorealtime m'affiche le méssage d'erreur suivant:
Erreur dans l'indicateur : gege test formules prt Détection de boucle sans fin.
Veuillez modifier la boucle correspondante

bonjour a tous
si dessous une des réponse de prorealtime:

Merci pour votre console.

Après analyse, il apparait que les deux codes présents sur cette page sont en effet érronés.
Nous allons corriger ces erreurs puis mettre une nouvelle version de notre manuel probuilder sur notre site.

En attendant, vous trouverez joint à ce mail les versions corrigés de ces deux codes.

Nous vous invitons à vous manifester à nouveau si vous rencontrez encore ce type de désagrément et vous remercions encore pour votre retour.

Code

IF BarIndex < 19 THEN
MMhigh = Undefined
ELSE
SUMhigh=0
FOR i = 0 TO 19 DO
SUMhigh = High+SUMhigh
NEXT
ENDIF
MMhigh = SUMhigh / 20
RETURN MMhigh

----------------------------------------------
IF BarIndex=0 THEN
MMhigh = Undefined
ELSE
SUMhigh=0
FOR i = 19 DOWNTO 0 DO
SUMhigh = High[ i] + SUMhigh
NEXT
ENDIF
MMhigh = SUMhigh / 20
RETURN Mmhigh

apperement t avait raison -> mea culpa

dans le pdf les codes , que j ai intalles et qui donnent un resultat qui est faux ( une droite croisante ) se trouvent page 21

https://www.prorealtime.com/fr/pdf/probuilder.pdf

Le codes de geraldcac donnent des courbes beaucoup crédibles .

Code : #

Code

IF BarIndex < 19 THEN
MMhigh = Undefined
ELSE
SUMhigh=0
FOR i = 0 TO 19 DO
SUMhigh = High[i]+SUMhigh
NEXT
ENDIF
MMhigh = SUMhigh / 20
RETURN MMhigh

----------------------------------------------
IF BarIndex=0 THEN
MMhigh = Undefined
ELSE
SUMhigh=0
FOR i = 19 DOWNTO 0 DO
SUMhigh = High[ i] + SUMhigh
NEXT
ENDIF
MMhigh = SUMhigh / 20
RETURN Mmhigh

Bonjour,
Je suis comme vous intéressé par tracer une droite entre deux points choisis mais je n'y arrive toujours pas. Vous avez trouvé sans la projection vers le future finalement? Je recherche un code qui me mette sur la bonne piste.

De mon point de vue tu ne peux pas tracer une droite dans prt, sauf à t'amuser à calculer les points de la droite à chaque Bougie.

Pour rappel la formule d'une droite affine c'est y = a.x + b ...

A mettre en oeuvre c'est pas du tout sorcier, mais est-ce réellement ce que vous voulez ?

Bonjour Falex,
J'ai du revoir quelques notions de math effectivement et j'ai le code de hk-lisse d'une droite de regression lineaire que j'ai des difficultés à comprendre pour pouvoir l'adapter.
Je veux tracer une droite entre deux plus bas par exemple pour faire un support qui se maintient sur les résultats suivants s'il n'est pas cassé.
Mon probleme est, que faire du resultat de l'indicateur lorsque la bougie ne correspond pas à un plus bas?
Pour l'instant j'ai un indicateur dont je calcul les plus bas et entre deux, j'ai programmé le plus bas précédent, ce qui donne un escalier.
Voici le code:
av=moyenne mobile

Code : #

LL=INDIC <AV1
HH=INDIC >AV1
iF  HH AND LL[1]  AND LL[2]  AND LL[3]  AND LL[4]   AND LL[5] THEN
indicL=LOWEST[10](INDIC)
ELSE
indicL=indicL[1]
ENDIF

ARf non c'est pas ça du tout.

J'ai un code avec une ligne droite (en fait il suffit de calculer Y pour chaque X), je vais vous retrouver ça.

Ce sont des extrait car c'est intégré dans un code plus complexe :

1er partie : Avec les point haut d'uen bougie HB11 et HB22, calcul de a et b.

Code : #

if opentime = HB11 then
y1 = high
x1 = barindex
elsif opentime = HB22 then
y2 = high
x2 = barindex
//Calcul du m et P car on a les deux points
DeltaY = y2 - y1
DeltaX = x2 - x1
m = DeltaY / DeltaX
//p = y1 - m * HB11
P = y1 //Ramené l'ordonné à l'origine à 0 pour éviter le modulo 60

Pour chaque bougie après ces deux bougies de référence calcul du Y

Code : #

if opentime > HB22 then
y = m * ((barindex - x2)+DeltaX) + p 

RAiko, mle bout de code que tu as donnée test des valeurs haut et base mais ne calcul pas un point, or quand tu veux tracer une droite c'est un point que tu veux calculer.

Bonjour,

Fiou, c'est pas facile. Je bataille toujours pour relier les plus hauts de mon indicateur par une droite. Je vois bien que le code que tu me donnes est logique mais j'arrive pas à l'adapter à mon indicateur.

C1=nouveau plus haut
Que dois je coder si "C1" et si "NOT C1"?

Je tatonne autour de ce code (dans cette exemple le plus haut précédent serait dans les 4 barres précédentes):

Code : #

iF   C1[1] and not C1 THEN

if C1[2] then
y1 = high
x1 = barindex
y2 = high[2]
x2 = barindex[2]
//Calcul du m et P car on a les deux points
DeltaY = y2 - y1
DeltaX = x2 - x1
m = DeltaY / DeltaX
//p = y1 - m * HB11
P = y1 //Ramené l'ordonné à l'origine à 0 pour éviter le modulo 60
y = m * ((barindex[2] - x2)+DeltaX) + p
elsif C1[3] then
y1 = high
x1 = barindex
y2 = high[3]
x2 = barindex[3]
//Calcul du m et P car on a les deux points
DeltaY = y2 - y1
DeltaX = x2 - x1
m = DeltaY / DeltaX
//p = y1 - m * HB11
P = y1 //Ramené l'ordonné à l'origine à 0 pour éviter le modulo 60
y = m * ((barindex[3] - x2)+DeltaX) + p
elsif C1[4] then
y1 = high
x1 = barindex
y2 = high[4]
x2 = barindex[4]
//Calcul du m et P car on a les deux points
DeltaY = y2 - y1
DeltaX = x2 - x1
m = DeltaY / DeltaX
//p = y1 - m * HB11
P = y1 //Ramené l'ordonné à l'origine à 0 pour éviter le modulo 60
y = m * ((barindex[4] - x2)+DeltaX) + p

ELSE
y=HIGHEST[4](INDIC)
ENDIF
ELSE
y1 = high
x1 = barindex
y2 = high[1]
x2 = barindex[1]
//Calcul du m et P car on a les deux points
DeltaY = y2 - y1
DeltaX = x2 - x1
m = DeltaY / DeltaX
//p = y1 - m * HB11
P = y1 //Ramené l'ordonné à l'origine à 0 pour éviter le modulo 60
y = m * ((barindex[1] - x2)+DeltaX) + p
ENDIF

Je sens que je suis encore loin de trouver alors si vous avez une piste à me donner ca me faciliterais les choses.