[TP6] Régles d'inférences - si quelqu'un à une idée

[burgha_j]

Bonjour à tous,

Voilà mes erreurs :

• test_VisiteursInstPour_AvecLaRègleDInférence(question3) failed

• test_VisiteursInstTantQue_AvecLaRègleDInférence(question3) failed

Voici ce que j'ai codé pour "respecter" ces règles d'inférence qui pour moi sont simplement des "hypothèses" à vérifier avant d'exécuter les instructions (et de modifier la mémoire).

Malgré pas mal de temps passé, je n'arrive pas à résoudre ce problème (personnellement je passe à autre chose j'ai perdu trop de temps et une belle journée ensoleillée sur cette question)

J'ai revue le cours vidéo plusieurs fois. Je ne vois pas quoi faire de plus. Pour le reste tout le code fonctionne.

Je jette mon code si quelqu'un à une idée :

Pour while :

• Je vérifie l'hypothèse et j'exécute uniquement si elle est vrai.

• Dans l'ordre : Instruction,

• Appel à While

Code : Tout sélectionner

    /**
     * La boucle tantque(Bexp,I1)<br>
     * <code>
     * 
     *     M,Bexp -interprete->faux              <br>
     * _________________________________________ <br>
     * M,tantque(Bexp) faire I1-interprete-> M   <br>
     * <br>
     * M,Bexp -interprete-> vrai                          <br>
     * M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1    <br>
     * ___________________________________________________<br>                 
     * M,tantque(Bexp)faire I1-interprete-> M1
     * </code>
     * 
     * @param tq une it�ration de la classe tantque
     * @return la m�moire r�sultante
     */
    public Contexte visite(TantQue tq) {
        if (tq.cond().accepter(this.vb)) {
            tq.i1().accepter(this);
            this.visite(tq);
        }
        return this.vi.contexte();
    }

Pour for :

• J'initialise systématiquement car, dans le cas contraire mes parcours sont en échec notamment dans le cadre de boucles imbriquées : ce qui est logique la mémoire n'étant pas remise à zéro on pourrait vérifier la condition directement.

• Je vérifie l'hypothèse et j'exécute uniquement si elle est vrai.

• Dans l'ordre : Instruction,

• Appel à While

La seul problématique que je vois c'est l'initialisation mais la logique veut qu'on "initialise" forcément avant de vérifier la condition lors de l'exécution du "pour".

Code : Tout sélectionner

    /**
     * La boucle pour(init,Bexp,inc)I1<br>
     * <code>
     * M,seq(init,tantque(Bexp)seq(I1,inc))-visite->faux <br>
     * _____________________________________________________ <br>
     * M,pour(init,Bexp,inc) faire I1-visite-> M         <br>
     * </code>
     * 
     * @param pour une it�ration de la classe Pour
     * @return la m�moire r�sultante
     */
    public Contexte visite(Pour pour) {
   
        pour.init().accepter(this);
        if (pour.cond().accepter(this.vb)) {
            this.visite(new TantQue(pour.cond(), new Sequence(pour.i1(), pour.inc())));
        }
 
        return this.vi.contexte(); 
    }

Si quelqu'un a une idée, je suis preneur. En attendant, je vais passer au TP suivant.

Bonne soirée à tous

[charp_n1]

Bonsoir,

Pour passer les tests, j'ai fait exactement ce qui est indiqué "au-dessus du trait" (les hypothèses à assurer), même si ça m'a semblé plus tordu que ce que j'avais d'abord écrit (le même code que toi).
Il y a peut-être une raison à cela, je ne l'ai pas comprise.

Bon courage

[burgha_j]

Je vais passer par des séquences, c'est la seule nuance que je vois. Même si je vois pas ce que ça va changer.

[douinj]

Bonjour,
Juste pour compléter et engendrer de petites discussions entre nous ;-)

Code : Tout sélectionner

  /**
     * <code>
     *     M,Bexp -interprete->faux             
     * _________________________________________ 
     * M,tantque(Bexp) faire I1-interprete-> M   
     * 
     * M,Bexp -interprete-> vrai                         
     * M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1   
     * ___________________________________________________             
     * M,tantque(Bexp)faire I1-interprete-> M1
     * </code>
     * 
     */
  

Si je tente de "recopier" les règles ci-dessus, nous pourrions obtenir

Code : Tout sélectionner

    public Contexte visite(TantQue tq) {
      if(tq.cond().accepter(this.vb)) new Sequence(tq.i1(), tq).accepter(this);
      return this.vi.contexte();
    }

ou encore, avec quelques libertés vis à vis des règles ( c'est à tester)

Code : Tout sélectionner

    public Contexte visite(TantQue tq) {
     return new Selection(tq.cond(),new Sequence(tq.i1(), tq)).accepter(this);
    }

[burgha_j]

Mon traitement le faisait en deux étapes donc l'une pouvait avoir lieu mais pas l'autre.

Je vois ici, que le but est de reproduire l'équivalent d'une transaction ou l'on ne peut accepter que le résultat que si les deux "sous instructions" sont réalisés en même temps ?

[charp_n1]

Bonjour,

Pour ma part je ne vois pas du tout en quoi faire une séquence qui va rejouer le TantQue est plus "correct" que de faire directement un appel récursif à TantQue, comme nous l'avions fait tous les deux (et comme sans doute plusieurs autres le feront). Ca revient à exécuter I1 dans la séquence plutôt que dans le TantQue : j'ai dû rater une marche car pour moi ça ressemble plus à un exercice de style qu'autre chose...
Quant à la notion de transaction évoquée par burgha_j, alors là je ne vois pas du tout...

Quelqu'un pourrait-il m'expliquer en quoi faire la récursion directement dans le TantQue est incorrect, et le bien-fondé de cette règle étrange imposée par la grammaire ? Pourquoi pas simplement :

* M,Bexp -interprete->faux
* _________________________________________
* M,tantque(Bexp) faire I1-interprete-> M
*
* M,Bexp -interprete-> vrai
* IMPOSÉ --> M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1
* PLUS "LOGIQUE" ? --> I1 ';' M, tantque(Bexp)faire I1-interprete-> M1
* ___________________________________________________
* M,tantque(Bexp)faire I1-interprete-> M1
* </code>
*
*/

(PS : je n'ai pas encore visualisé le podcast de mardi, mes excuses par avance si la réponse y a déjà été apportée)

[douinj]

Bonjour, juste pour l'écriture

* M,Bexp -interprete->faux
* _________________________________________
* M,tantque(Bexp) faire I1-interprete-> M
*
* M,Bexp -interprete-> vrai
* IMPOSÉ --> M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1
* PLUS "LOGIQUE" ? --> I1 ';' M, tantque(Bexp)faire I1-interprete-> M1
* ___________________________________________________
* M,tantque(Bexp)faire I1-interprete-> M1
* </code>
*
*/

* M,Bexp -interprete->faux
* _________________________________________
* M,tantque(Bexp) faire I1-interprete-> M
*
* M,Bexp -interprete-> vrai
* IMPOSÉ --> M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1
* PLUS "LOGIQUE" ? -->M I1 ';' M1, tantque(Bexp)faire I1-interprete-> M2
* ___________________________________________________
* M,tantque(Bexp)faire I1-interprete-> M2
* </code>
*
*/

à suivre...

[burgha_j]

Bonjour,

Pour ma part je ne vois pas du tout en quoi faire une séquence qui va rejouer le TantQue est plus "correct" que de faire directement un appel récursif à TantQue, comme nous l'avions fait tous les deux (et comme sans doute plusieurs autres le feront). Ca revient à exécuter I1 dans la séquence plutôt que dans le TantQue : j'ai dû rater une marche car pour moi ça ressemble plus à un exercice de style qu'autre chose...
Quant à la notion de transaction évoquée par burgha_j, alors là je ne vois pas du tout...

Quelqu'un pourrait-il m'expliquer en quoi faire la récursion directement dans le TantQue est incorrect, et le bien-fondé de cette règle étrange imposée par la grammaire ? Pourquoi pas simplement :

* M,Bexp -interprete->faux
* _________________________________________
* M,tantque(Bexp) faire I1-interprete-> M
*
* M,Bexp -interprete-> vrai
* IMPOSÉ --> M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1
* PLUS "LOGIQUE" ? --> I1 ';' M, tantque(Bexp)faire I1-interprete-> M1
* ___________________________________________________
* M,tantque(Bexp)faire I1-interprete-> M1
* </code>
*
*/

(PS : je n'ai pas encore visualisé le podcast de mardi, mes excuses par avance si la réponse y a déjà été apportée)

j'ai l'impression que c'est la notion d' "atomocité" qui rentre en compte : on "doit faire les deux pas en même temps". Si l'un modifie la mémoire et que l'autre ne la modifie pas on est dans un "contexte" mémoire qui n'est pas celui attendue au niveau intérmédiaire. On peut donc avoir un cas, sur "erreur" par exemple ou la mémoire à changé "à moitié" : https://fr.wikipedia.org/wiki/Atomicit% ... matique%29

[bouty_g]

Bonjour à tous,
Petit retour d'expérience perso... J'ai eu la même erreur que vous sur le Pour. Après relecture de l'énoncé, j'ai déduit qu'il fallait uniquement travailler avec les expressions du langage créé (sauf pour la Selection, à un moment faut bien utiliser un petit quelque chose)...Du coup j'en arrive aux codes suivants :

Code : Tout sélectionner

    public Contexte visite(TantQue tq){
        Selection s = new Selection(
                        tq.cond(), new Sequence(tq.i1(), tq)
                        );
        s.accepter(this);
        return this.contexte();
    }

où j'appelle le TantQue récursivement...

et de l'autre côté:

Code : Tout sélectionner

    public Contexte visite(Pour pour) {
        Sequence seq = new Sequence(
                pour.init(),
                new TantQue(
                        pour.cond(),
                        new Sequence(pour.i1(), pour.inc())
                )
        );
        seq.accepter(this);
        return this.contexte();
    }

où le pour doit être intégré à une seule séquence (sinon je ne passe pas le test).

Je comprends la logique, mais j'avoue que pour moi aussi ça a été un peu capilotracté l'histoire !
Pour moi ce TP est un bon step au-dessus des autres (croisement de DP un poil abstrait à mon gout + un exercice de style pas très simple dans la "conception d'un nouveau langage").

Je ne comprends pas trop ce que vous entendez avec les notions "d'atomicité" et de "transaction". Qu'est ce que vous avez voulu dire ?

++

[moro_al]

Alors d'abord, merci a vous pour ce fil, j'en perdais mon latin ... euh java.
j'ai moi même plongé a pieds joints dans l oublie de seq pour la règle :

M,seq(init,tantque(Bexp)seq(I1,inc))-visite->faux

Je n'avais pas "compris" (oui je suis un peu lent) que l'on visitait la séquence qui englobait l'ensemble du traitement.
La mémoire n'est retournée modifiée qu'une fois la séquence complète effectuée et si bien sur elle est "vrai" ou ( totalement réalisée).

Je ne comprends pas trop ce que vous entendez avec les notions "d'atomicité" et de "transaction". Qu'est ce que vous avez voulu dire ?

Pour l'atomicité / transaction je le comprend comme un enchainement d'instructions (ici toute la seq) que l'on ne peut interrompre /visiter tant que l'on a pas fini le traitement.

Juste par rapport a ce M. douin a mis plus haut :

M,seq(I1,tantque(Bexp)faire I1)-interprete-> M1

ne serait-on pas plus dans un do - while qu'un while ?