EMG2 : Approfondissement des pseudo-fonctions

I Introduction
Le tutoriel suivant a été rédigé comme une suite du tutoriel #1, à lire de préférence avant sinon vous risquez d'être un peu largués.

Dans ce tutoriel nous verrons par le biais d'un cas plus théorique une application un peu plus complexe de la factorisation.

II Problématique
Admettons que nous voulions faire un code qui prenne un nombre et calcule son plus grand facteur premier. Par exemple en prenant 42 il trouverait que 42 = 2 * 3 * 7 et donc afficherais 7. Pour ce faire, voici une solutions possible au problème, en pseudo code :

Code:

V[1] = 42
boucle
  si V[1] est un nombre premier
    soritr de la boucle
  fin de condition
  V[2] = le plus petit diviseur de V[1]
  V[1] = V[1]/V[2]
fin de boucle
afficher V[1]

Voici donc ce que fera le code :

- V[1] vaut 42
- Entrée dans la boucle
- V[1] est-il premier ? Non. On reste dans la boucle
- V[2] devient le plus petit diviseur de V[1] -> 2
- V[1] devient le résultat de la division de V[1] par V[2] soit 42/2 ou 21
- On revient au début de la boucle
- V[1] est-il premier ? Non. On reste dans la boucle
- V[2] devient le plus petit diviseur de V[1] -> 3
- V[1] devient le résultat de la division de V[1] par V[2] soit 21/3 ou 7
- On revient au début de la boucle
- V[1] est-il premier ? Oui. On sort de la boucle
- On affiche, comme attendu, 7

III Transformation en code event
Puisque ce tutoriel porte sur la factorisation du code, nous allons évidemment réutiliser le principe exploré dans le tuto précédent, à savoir utiliser des events communs pour exécuter du code générique.
Cependant, une chose vous a peut-être fait tiquer dans le pseudo code ce-dessus, il s'agit du fait que le calcul du plus petit diviseur et celui pour savoir si un nombre est premier n'ont pas été définis.  J'aurais très bien pu écrire le code supplémentaire mais il me semble important de vous le montrer sous cette forme pour vous aider à percevoir une chose dans la sérialisation : c'est que, dans la mesure où un event commun peut être appelé n'importe où, il est tout à fait possible d'utiliser le même principe de sérialisation à partir d'un autre event commun.

Ce que ça signifie ? Qu'on va utiliser un second event commun pour vérifier si un nombre est premier, qu'on utilisera le résultat dans le premier pour la que structure du code située plus haut reste plus où moins la même.

IV Le code en question

Tout d'abord, voici le code dans l'event qui appellera le tout :



Ensuite l'event commun appelé dans ce dernier :



Et enfin l'event commun qui définit si un nombre est premier :



Je vais rapidement vous expliquer le fonctionnement de ce dernier event. En fait la boucle incrément la variable 37 jusqu'à ce qu'une des deux conditions soit validée, à savoir :
Si la variable 37 est égale à la variable 36, ce qui signifie que la variable 36 contient un nombre premier.
Si la variable 38, qui est initialisée au modulo de la variable 36 par la variable 37, est égale à 0. Signifiant que le contenu de la variable 36 est un multiple de celui de la variable 37 et donc que la variable 36 ne contient pas un nombre premier.
Quelle que soit la condition, l'interrupteur 3 est modifié en conséquence pour définir si oui où non il s'agit d'un nombre premier.

Et c'est cet interrupteur qui va servir dans le premier event commun pour déterminer si on continue ou non la boucle.
D'ailleurs vous remarquerez que je n'utilise pas d'event commun pour trouver le plus petit diviseur du contenu de la variable 36. C'est du au fait que le code utilisé pour déterminé si le nombre est premier ou non le fait en fait en tentant de trouver son plus petit diviseur et de déduire que le nombre et premier si ce diviseur n'est autre que lui-même.
De fait, quand le nombre n'est pas premier, son plus petit diviseur a déjà été calculé et se trouve encore dans la variable 38. Il ne reste donc plus qu'à l'utiliser !

V Conclusion
C'est donc la fin de ce tuto #2 avec un exemple par forcément très pertinent pour le making mais qui j'espère vous donnera un meilleur sens de ce que cette technique ouvre comme possibilités !

Donc pour résumer ce qu'il faut retenir de ces deux tutos c'est que :
- On peut utiliser la technique à partir de n'importe quel code et donc faire des pseudos fonctions qui utilisent des pseudos fonctions.
- En fait quand un event commun a finit de s’exécuter, les variables et les interupteurs qu'il utilise sont encore accessibles dans le code (comme ici avec l'interrupteur 3 et la variable 38)
- Et surtout, surtout, les pseudos fonctions permettent, en quelque sorte, d'implémenter vos propres commandes (c'est d'autant plus clair avec l'exemple du tuto #1 qui permet de calculer des puissances, chose impossible nativement).