Comparer valeur précedente dans boucle

Viewing 11 posts - 1 through 11 (of 11 total)
  • Author
    Posts
  • #146425 quote
    Be-n
    Participant
    Average

    Bien le bonjour !

    Je me permets de solliciter votre attention concernant une problèmatique qui a déjà été soulevée me semble-t-il. J’insiste néanmoins afin de trouver auprès de vous une solution et/ou alternative. La prog a cela de captivant : contourner les obstacles. Pour ma part, j’ai usé ma logique sur cette difficulté……

    Je m’explique donc :

    Je souhaite réaliser une boucle et retenir le resultat ($x) le plus intéressant. L’ennui est que je n’arrive pas à “mémoriser” le résultat précédent afin de pouvoir comparer mes valeurs entre elles ($resultat et $resultatPrecedent) comprises entre i et i+1… J’ai écumé un peu le forum où il est question d’utiliser les array (disponibles à partir de la version 11). Est-il possible en attendant de passer outre ?

    Dans mon exemple, je souhaite comparer différents niveaux de fractales et retenir le niveau le plus près de mon seuil ($seuil) sans que ce niveau soit supérieur à $seuil.

    Voici mon code :

    seuil=1.17178
    resultat=0
    
    FOR i=1 TO 5 DO
    
       IF (low[0] <= lowest[((i)*2+1)+0](low[0])[0]) THEN
          niveau=low[0]
       ENDIF
    
       resultatPrecedent=resultat //Ne fonctionne pas : resultatPrecedent=resultat
       PostScriptumPrecedent=PostScriptum //Fonctionne : PostScriptumPrecedent<>PostScriptum
    
       IF niveau<seuil THEN
          resultat=seuil-niveau
       ELSE
          resultat=resultatPrecedent
          CONTINUE
       ENDIF
    
       PostScriptum=PostScriptum+1
    
       IF ((resultat<resultatPrecedent) AND (resultatPrecedent>0)) OR (resultatPrecedent=0 AND i=1) THEN
          x=niveau
          boucle=i
       ELSE
          x=x
          boucle=boucle
       ENDIF
    
    NEXT

    Ce que j’attendrais dans le meilleur des mondes si $seuil=1.17178 :

    +   i   ++  $niveau  ++       x      ++  boucle ++  resultat ++  resultatPrecedent +

    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    +   1  ++  1.17078  ++ 1.17078 ++      1      ++  0.00100  ++                 0              +

    +   2  ++  1.17120  ++ 1.17120 ++      2      ++  0.00058  ++           0.00100         +

    +   3  ++  1.16500  ++ 1.17120 ++      2      ++  0.00058  ++           0.00058         +

    +   4  ++  1.17110  ++ 1.17120 ++      2      ++  0.00058  ++           0.00058         +

    +   5  ++  1.17160  ++ 1.17160 ++      5      ++  0.00018  ++           0.00058         +

    ++           0.00018         +

    Là où le bât blesse :

    $resultatPrecedent me renvoie la même valeur que $resultat[i] au lieu de me renvoyer la valeur de la boucle précédente c-a-d resultat[i-1]

    De ce fait, je n’ai aucun moyen de comparer $resultat et $resultatPrecedent dans la mesure où $resultat est systématiquement et strictement égale à $resultatPrecedent

    PS : Je me suis “amusé” à incrémenter une variable ($PostScriptum) et dans ce cas, ça fonctionne : $PostScriptum est différent de $PostScriptumPrecedent et ces valeurs peuvent être comparées…

    Merci d’avance de votre aide la communauté ! A u plaisir de vous lire 😉

    #146436 quote
    JC_Bywan
    Moderator
    Master

    Bjr,

    Pour info et dans un souci de clarté dans le cadre de la modération du forum, étant donné que les tableaux(arrays) en v11 utilisent le symbole $ il vaudra mieux dans les prochains messages ne pas utiliser $ pour dénommer des variables simples afin d’éviter toute confusion entre une variable et un tableau(array) pour les lecteurs.

    J’imagine que tes data sont sur eurusd, mais n’ayant ni timeframe ni dates et heures de l’exemple je ne peux pas tester sur exactement le même échantillon, essayer avec ceci?

    seuil=1.17178
    resultat=0
    resultatPrecedent=0
    niveau=seuil
     
    FOR i=1 TO 5 DO
     
     IF (low<=lowest[2*i+1](low)) THEN
       niveau=low
     ENDIF
    
     if resultat<>0 then
       resultatPrecedent=resultat
     endif
    
     IF niveau<seuil THEN
       resultat=seuil-niveau
       if resultat<resultatPrecedent or resultatPrecedent=0 then
         x=niveau
       ENDIF
     ENDIF
     
    NEXT
    
    return x as "x"
    Be-n thanked this post
    #146579 quote
    Be-n
    Participant
    Average

    Bonjour Noobywan, merci de ta réponse ! C’est noté pour les $ 😉

    J’ai essayé ton code mais les résultats sont assez erratiques. J’ai d’ailleurs un peu de mal à comprendre et interpréter ceux-ci. Quelque chose m’échappe…

    J’ai modifié mes conditions afin de retenir – cette fois – l’écart le plus grand entre ma limite=close*1.10 et mon niveau de fractale le plus bas selon [2*i+1]. Ceci afin que les résultats soient (davantage) différents selon la timeframe et la devise.

    En effet, lors de mon précédent exemple (où l’on cherchait l’écart le plus petit), l’écart minimum était obtenu dès la première boucle (bien souvent)… donc pas facile pour tirer des conclusions lors des tests…

    Voilà mon code (modifié précedemment par  Noobywan) :

    limite=close*1.10
    resultat=0
    resultatPrecedent=0
    niveau=limite
     
    FOR i=1 TO 5 DO //J'ai également essayé avec i=5 DOWNTO 1 mais là les résultats sont complètement étranges......
    
        IF (low<=lowest[2*i+1](low)) THEN
            niveau=low
        ENDIF
     
        if resultat<>0 then
            resultatPrecedent=resultat
        endif
     
        IF niveau<limite THEN
    
            resultat=limite-niveau
    
        IF resultat>resultatPrecedent OR resultatPrecedent=0 THEN //Dans cette exemple, je cherche l'écart le plus grand où resultat>resultatPrecedent
            x=niveau //Niveau de fractale le plus bas afin d'obtenir l'écart le plus grand par rapport à ma limite=close*1.10
            boucle=i //boucle dans laquelle je me trouve
        ENDIF
    
    ENDIF
     
    NEXT
    
    GRAPH limite
    GRAPH resultat
    GRAPH resultatPrecedent
    GRAPH x
    GRAPH boucle

    Pour information, j’effectue mon backtest sur l’EURUSD sur la timeframe 1H en temps réel mais les tests peuvent s’effectuer sur toutes les paires et/ou timeframes

    Merci d’avance de vos retours ! 😉

    #146583 quote
    JC_Bywan
    Moderator
    Master

    Je ne suis pas tombé sur des cas erratiques. Mais si tu changes la recherche pour passer de l’écart mini au maxi, j’ai l’impression que ta question n’était peut être pas tant de trouver le mini, que de voir ce qu’il se passe dans la boucle? Si c’est ça, alors il faut garder à l’esprit une chose: l’indicateur ne t’affichera qu’un seul jeu de valeurs par bougie, donc tu ne pourras pas voir toutes les itérations de la boucle en stockant une seule fois “résultatprécédent” qui parfois n’enclenchera pas, parfois sera écrasé une ou plusieurs fois par un successeur pour n’afficher que le dernier resultatprecédent en clôture… Si tel est le cas, vu que la boucle est petite, tu peux facilement avec un if sur le i stocker resu1, resu2, resu3, resu4, resu5 et retourner ces 5 valeurs dans la ligne return, pour mieux décortiquer ce qu’il se passe dans la boucle.

    #146589 quote
    Be-n
    Participant
    Average

    Re Noobywan ! Merci de ton retour,

    Mais si tu changes la recherche pour passer de l’écart mini au maxi, j’ai l’impression que ta question n’était peut être pas tant de trouver le mini, que de voir ce qu’il se passe dans la boucle?

    Effectivement, j’essaye de comprendre concrètement ce qui se passe au sein de cette boucle. Logiquement, je m’attendrais à trouver certains résultats , ce qui n’est pas le cas malheureusement…

    A partir du code ci-dessous sur l’EURUSD 4H (afin que l’on parle des mêmes choses 😉 ), je m’attendrais donc à trouver les valeurs suivantes :

    limite = 1.29704

    boucle = 5 //itération qui correspond à la condition (resultat>resultatPrecedent OR resultatPrecedent=0)

    x = 1.16959 /niveau de fractale le plus bas

    resultat = 0.13557 //écart maxi en cours

    resultatPrecedent = 0.12745 //écart maxi précédent en cours…

    Or, je trouve depuis le backtest :

    limite = 1.29704

    boucle = 1

    x = 0

    resultat = 0

    resultatPrecedent = 0

    ………………….. :'(

    limite=close*1.10
    resultat=0
    resultatPrecedent=0
    niveau=limite
     
        FOR i=1 TO 5 DO
            IF (low<=lowest[2*i+1](low)) THEN
            niveau=low
        ENDIF
     
        IF resultat<>0 THEN
            resultatPrecedent=resultat
        ENDIF
     
        IF niveau<limite THEN
    
            resultat=limite-niveau
    
            IF resultat>resultatPrecedent OR resultatPrecedent=0 THEN //Dans cette exemple, je cherche l'écart le plus grand où resultat>resultatPrecedent
                x=niveau //Niveau de fractale le plus bas afin d'obtenir l'écart le plus grand par rapport à ma limite=close*1.10
                boucle=i
            ENDIF
    
        ENDIF
     
    NEXT
    
    GRAPH limite
    GRAPH resultat
    GRAPH resultatPrecedent
    GRAPH x
    GRAPH boucle

    Merci d’avance !

    #146595 quote
    JC_Bywan
    Moderator
    Master

    Je recommande un indicateur à mettre en dessous de la fenêtre prix plutôt qu’un backtest, on peut voir plus de variables, et mieux customiser style et couleurs de lignes (et on est dans le forum probuilder)

    Voici pour voir chacun des 5 pas de la boucle:

    limite=close*1.10
    resultat=0
    resultatPrecedent=0
    niveau=limite
     
    FOR i=1 TO 5 DO
    IF (low<=lowest[2*i+1](low)) THEN
    niveau=low
    ENDIF
     
    IF resultat<>0 THEN
    resultatPrecedent=resultat
    ENDIF
     
    IF niveau<limite THEN
     
    resultat=limite-niveau
     
    IF resultat>resultatPrecedent OR resultatPrecedent=0 THEN //Dans cette exemple, je cherche l'écart le plus grand où resultat>resultatPrecedent
    x=niveau //Niveau de fractale le plus bas afin d'obtenir l'écart le plus grand par rapport à ma limite=close*1.10
    boucle=i
    ENDIF
     
    ENDIF
    
    if i=1 then
    resultat1=resultat
    resultatPrecedent1=resultatPrecedent
    x1=x
    boucle1=boucle
    elsif i=2 then
    resultat2=resultat
    resultatPrecedent2=resultatPrecedent
    x2=x
    boucle2=boucle
    elsif i=3 then
    resultat3=resultat
    resultatPrecedent3=resultatPrecedent
    x3=x
    boucle3=boucle
    elsif i=4 then
    resultat4=resultat
    resultatPrecedent4=resultatPrecedent
    x4=x
    boucle4=boucle
    elsif i=5 then
    resultat5=resultat
    resultatPrecedent5=resultatPrecedent
    x5=x
    boucle5=boucle
    endif
    
    NEXT
     
    return limite as "limite", resultat1 as "resultat1", resultat2 as "resultat2", resultat3 as "resultat3", resultat4 as "resultat4", resultat5 as "resultat5", resultatPrecedent1 as "resultatPrecedent1", resultatPrecedent2 as "resultatPrecedent2", resultatPrecedent3 as "resultatPrecedent3", resultatPrecedent4 as "resultatPrecedent4", resultatPrecedent5 as "resultatPrecedent5", x1 as "x1", x2 as "x2", x3 as "x3", x4 as "x4", x5 as "x5", boucle1 as "boucle1", boucle2 as "boucle2", boucle3 as "boucle3", boucle4 as "boucle4", boucle5 as "boucle5"
    #146628 quote
    Nicolas
    Keymaster
    Master

    Pour bien comprendre, faut-il trouver un fractal du passé qui est le plus près du prix actuel ? Si oui tu es certain de la définition de ces fractals avec ta formule: low<=lowest[2*i+1](low) ??

    #146636 quote
    Be-n
    Participant
    Average

    Pour bien comprendre, faut-il trouver un fractal du passé qui est le plus près du prix actuel ?

    Effectivement, l’idée serait de trouver un fractal du passé qui est le plus près (ou le plus éloigné) du prix actuel par exemple. J’ai pris l’exemple des fractals pour illustrer mon problème au sein de cette boucle d’itération. A l’issu de cette boucle, j’aimerais obtenir chaque résultat au sein d’une seule et même variable si possible. Par exemple, à l’itération n°5 (sortie boucle = 5), mon fractal le plus éloigné du prix (sortie resultat) est situé à tel prix (sortie x)…

    Si oui tu es certain de la définition de ces fractals avec ta formule: low<=lowest[2*i+1](low) ??

    Cette formule “agrandie” à chaque itération l’échantillon de bougie à étudier, soit le niveau/prix le plus bas pour 3 bougies, 5, 7, 9 …

    #146673 quote
    Be-n
    Participant
    Average

    Si je remplace :

    IF (low<=lowest[2*i+1](low)) THEN
        niveau=low
    ENDIF

    par :

    niveau=low[i]

    … afin de trouver le plus bas (sur i périodes) par rapport au prix actuel, alors dans ce cas, j’obtiens parfaitement les réponses que je souhaite pour x, boucle, resultat et resultatPrecedent

    Cf. image en pj avec à gauche les résultats pour niveau=low[i]

    resultat_02.png resultat_02.png
    #146690 quote
    Be-n
    Participant
    Average

    Si oui tu es certain de la définition de ces fractals avec ta formule: low<=lowest[2*i+1](low) ??

    Je viens de comprendre le sens de ta question Nicolas… désolé 🥴

    Dans cette itération, la formule ci-dessus ne compare que mon dernier low[0] au plus bas des … 3, 5, 7, 9, 11 plus bas précédents et si ce low[0] n’est jamais inférieur, mes résultats sont “bloqués” à la première itération……….. alors que je cherche effectivement à “trouver un fractal du passé qui est le plus près du prix actuel” …. 🤯

    Dans ce cas, comment m’y prendre ? 🤔🥺

    #146706 quote
    Nicolas
    Keymaster
    Master

    Ce serait nettement plus facile avec les tableaux en v11, voir par exemple cette détection de supports et résistances avec des fractals du passé justement (ils sont tous placés dans un tableau que l’on “scanne” dans une boucle à chaque nouvelle bougie) https://www.prorealcode.com/topic/array-variables-availability-in-prorealtime/#post-118817

    En v10.3, voilà la solution ce que je te propose, bien entendu on doit limiter la boucle dans l’historique sinon les calculs seront très long !

    // settings 
    priceLevel = 1.17178
    FractalPeriod = 3
    barLimit = 200
    // ----------------
    
    // ------------------
    //defining low fractals
    
    cp=FractalPeriod
    
    if low[cp] <= lowest[2*cp+1](low)  then
    LL= -1
    else
    LL=0
    endif
    
    if LL  = -1 then
    LOL = low[cp]
    DRAWTEXT("▲",barindex[cp],lol,Dialog,Bold,12) //coloured(100,100,100,100)
    fractal=lol
    endif
    
    // -----------------
    //looking for the nearest fractal to priceLevel
    
    diff=priceLevel*10
    lastfractal=0
    lastdiff=0
    for i = 0 to barLimit-1 do 
    if fractal[i]>0 and lastFractal<>fractal[i] then 
    diff=min(diff,abs(fractal[i]-priceLevel))
    if diff<>lastdiff then 
    nearestFractal=fractal[i]
    endif
    lastFractal=fractal[i]
    lastdiff=diff
    endif
    next
    
    return nearestFractal,pricelevel coloured(200,200,0)

    La ligne orange est ton seuil de prix et la ligne blanche le niveau du fractal bas le plus proche de celle-ci dans les 200 dernières bougies en arrière, depuis chaque bougie.

    icharttop thanked this post
    fractal-low-nearest-price.png fractal-low-nearest-price.png
Viewing 11 posts - 1 through 11 (of 11 total)
  • You must be logged in to reply to this topic.

Comparer valeur précedente dans boucle


ProBuilder : Indicateurs & Outils Personnalisés

New Reply
Author
author-avatar
Be-n @be-n Participant
Summary

This topic contains 10 replies,
has 3 voices, and was last updated by Nicolas
5 years, 4 months ago.

Topic Details
Forum: ProBuilder : Indicateurs & Outils Personnalisés
Language: French
Started: 10/05/2020
Status: Active
Attachments: 2 files
Logo Logo
Loading...