Depuis plus de 5 ans, des élèves ayant quelques difficultés à conceptualiser les notions de variable et d’évaluation d’expressions algébriques, réclament que leur calculatrice permette de programmer en Sofus, langage de programmation qui étend d’une certaine manière ce bouton des calculatrices bas de gamme :
C’est désormais possible, grâce à un portage de Sofus en Python :
Mais il a fallu pour cela passer par la programmation objet, et le présent article est non seulement une initiation à la programmation Sofus sur calculatrices, mais aussi, une initiation à la programmation objet, les objets concernés étant les variables de Sofus.
En attendant que l’un des constructeurs de calculatrices crée une application Sofus pour calculatrice, voici comment on peut programmer en Sofus sur une calculatrice programmable en Python :
Sur Numworks, il suffit de se rendre sur cette page à l’aide du logiclel Chrome et là, une fois la Numworks connectée, de cliquer sur le bouton
Sur Casio, brancher la calculatrice sur un ordinateur en mode USB (ceci fera apparaître un dossier sur l’ordinateur ; ce dossier n’est autre que la Casio) puis copier-coller le script Python ci-dessous dans le dossier Casio. Après avoir déconnecté la Casio, on peut la programmer en Sofus.
Sur Ti, il est nécessaire de disposer de la dernière version du logiciel Ti-Connect pour être en mesure de charger un script Python sur la calculatrice Ti 83 Premium CE Python. Si on ne dispose que de la Ti 83 Premium CE, on peut, à l’aide du logiciel Ti-Connect, y transférer le fichier SOFUS.8xv ci-dessous
version Python pour Casio ou nouvelle TI
Version 8xv
Si le fichier sofus.py ci-dessus pose problème parce qu’il a été « zippé », on peut aussi le télécharger, « dézippé » en cliquant sur le lien télécharger ci-dessous :
Le principe de la programmation objet est de faire accomplir les tâches non pas directement par la machine, mais par des objets auxquels on s’adresse par envoi de messages. Par exemple, si je veux savoir ce qu’il advient de la variable prix après une augmentation de 5 pourcents, je lui demande de s’augmenter elle-même de 5 pourcents ce qui s’écrit augmente_toi_de(5,pourcents). Mais pour que cette requête aie des chances d’aboutir, il faut que
L’objet qui s’appelle prix soit capable de s’augmenter de 5 pourcents : On dit qu’il doit posséder une méthode (informatique) d’augmentation ;
Je précise à qui je donne l’ordre d’augmenter (cela n’a en général pas le même effet sur moi, que l’on augmente mon pouvoir d’achat ou le coût de la vie !). Tant que j’écris augmente_toi_de(5,pourcents) aucun objet ne fera rien, faute de savoir à qui l’ordre est donné. En Python, on précède un ordre (qui est d’ailleurs le nom de la méthode) du nom du destinataire, séparés par un point. Comme dans prix.augmente_toi_de(5,pourcents) qui est à lire comme « Ohé prix, je m’adresse à toi : Augmente toi de 5 pourcents »
Le nom de Sofus vient d’une allusion à la théorie des groupes de Lie et à son créateur Sophus Lie qui ramenait les transformations à des compositions de transformations simples, dites infinitésimales. Les transformations qui peuvent s’appliquer à une variable Sofus sont en fait les méthodes que possède cette variable (puisque la variable est chargée de se transfomer elle-même, sur demande) et en voici la liste, spécifique du langage Sofus :
augmente_toi_de() permet d’augmenter la variable d’une quantité à préciser (ou d’un pourcentage à préciser). Par exemple si la valeur actuelle d’une variable est 8, augmente_toi_de(5) la fera passer à 13 et augmente_toi_de(5,pourcents) la fera passer à 8,4
diminue_toi_de() permet de diminuer la variable d’une quantité (ou d’un pourcentage) à préciser. Par exemple si la valeur actuelle d’une variable est 8, le message diminue_toi_de(5) la fera passer à 3 ;
multiplie_toi_par() permet de faire agir un facteur (à préciser) sur la variable [1]. Par exemple si la valeur actuelle d’une variable est 8, le message multiplie_toi_par(5) va la transformer en 40 et le message multiplie_toi_par(5,pourcents) va la transformer en 0,4 (soit 40% de 8). Des variantes existent comme
double_toi() qui a le même effet que multiplie_toi_par(2)
triple_toi() qui a le même effet que multiplie_toi_par(3)
decuple_toi() qui a le même effet que multiplie_toi_par(10)
divise_toi_par() permet de diviser une variable par un nombre (éventuellement donné en pourcents). Par exemple si la valeur actuelle d’une variable est 8, divise_toi_par(5) la transforme en 1,6 et divise_toi_par(5,pourcents) la transforme en 160.
eleve_toi() éleve une variable à une puissance à fournir. Pour que Sofus reste proche de la langue française, l’exposant est donné sous la forme d’une fonction appelée a_la_puissance(). Par exemple si la valeur actuelle d’une variable est 8, le message eleve_toi(a_la_puissance(5)) aura pour effet de l’élever à la puissance 5 ce qui la transformera en 32768. Sofus propose aussi les abréviations suivantes :
eleve_toi(a_la_puissance(3)) s’abrège en eleve_toi(au_cube)
eleve_toi(a_la_puissance(2)) s’abrège en eleve_toi(au_carre)
eleve_toi(a_la_puissance(-1)) s’abrège en inverse_toi() (avec des parenthèses vides parce que c’est la syntaxe des méthodes d’un objet)
Il y a d’autres méthodes de l’objet variable de Sofus que celles permettant de faire varier les variables :
__repr__ permet à l’objet d’avoir une représentation visible. En l’occurence, on demande que si une variable soit évaluée (par exemple dans la console) le résultat de l’évaluation soit la valeur de la variable.
__str__ est une méthode de conversion en chaîne de caractères. Elle permet que si v est une variable Sofus, print(v) n’affiche pas Variable object mais la valeur de la variable.
Enfin la méthode __init__ est particulière en ce qu’elle ne s’applique pas à l’objet mais à sa classe : Elle a pour effet de faire naître un objet de type Variable (en initialisant sa valeur, d’où le nom de cette méthode). Mais il n’est pas possible pour un objet non encore né, d’entendre le message lui disant de naître. Parce que tant qu’on n’est pas encore né, on n’entend rien. C’est donc à la classe Variable qu’est envoyé le message de naissance, ce qui a pour effet de faire naître un objet de cette classe (une variable Sofus) lequel, ensuite, pourra entendre les autres messages et varier selon les desiderata du programmeur et les messages que celui-ci enverra à la variable.
Pour créer une variable Sofus appelée prix et l’initialiser à la valeur 8, il faut donc écrire dans la console (ou dans un module, après avoir entré from sofus import *) le code
Une variable (informatique) est décrite comme « un symbole qui associe un nom et une valeur ». Une variable de Sofus doit donc posséder, outre ses méthodes, au moins un nom et une valeur. Cette notion est fondamentale dans le modèle de Dana Scott et Christopher Strachey pour qui un ordinateur (ou une calculatrice) est une machine à états fini, chaque état étant un ensemble de variables.
Dans Sofus, la valeur de la variable prix est notée prix.valeur ce qui est cohérent avec les notations de la programmation objet. Et la valeur de la variable courante (celle à qui on s’adresse) s’appelle, self.valeur ce qui peut se traduire par « ma valeur à moi »
Python aussi a ses variables, on y accède directement par leur nom. Et pour initialiser une variable on l’affecte ce qui se fait par un signe d’égalité. Voici une équivalence approximative entre Sofus et Python, concernant une variable v initialisée à 8 :
version Sofus
version Python
v = Variable(8)
v=8
v.augmente_toi_de(5)
v+=5
v.augmente_toi_de(5,pourcents)
v *= 1.05
v.diminue_toi_de(5)
v-=5
v.diminue_toi_de(5,pourcents)
v *= 0.95
v.multiplie_toi_par(5)
v*=5
v.multiplie_toi_par(5,pourcents)
v *= 0.05
v.divise_toi_par(5)
v/=5
v.divise_toi_par(5,pourcents)
v /= 0.05
v.eleve_toi(a_la_puissance(5))
v**=5
v.eleve_toi(au_cube)
v**=3
v.eleve_toi(au_carre)
v**=2
v.inverse_toi()
v=1/v
v.double_toi()
v*=2
v.triple_toi()
v*=3
v.decuple_toi()
v*=10
Comme on le voit, la syntaxe de Python est bien plus concise que celle de Sofus, mais aussi plus éloignée de la langue naturelle (qui prononce l’expression « fois-égale » dans la vie de tous les jours ?). Et le portage de Sofus en Python aboutit à cette solution mixte, avec des variables des deux types : Quand on écrit
prix = Variable(100)
on crée une variable de Python appelée prix, et dont la valeur est un objet de type « variable de Sofus » ayant la valeur initiale 100. Cette subtilité n’est pas importante pour qui veut juste programmer en Sofus sur la calculatrice.
La principale difficulté que présente la calculatrice pour la programmation, que ce soit en Python ou en Sofus, est l’usage du clavier, dont l’ergonomie ne vaut pas, et de loin, celle du clavier d’on ordinateur. Aussi, pour éviter le risque que l’utilisateur se cantonne à des noms de variables d’une seule lettre (sans parler des instructions dont le nom se doit d’être long si on veut qu’il soit explicite), les constructeurs de calculatrice ont opté depuis longtemps pour la navigation dans les menus. Avec par exemple ce bouton :
qui permet de naviguer dans les variables déjà définies dans la session. Du moins avec la Numworks et la Ti, parce que pour l’instant ce bouton est inopérant sur la Casio. Mais la programmation Python étant pour l’instant considérée plus comme « fonctionnelle » que comme « objet », les classes et leurs méthodes n’apparaissent pas dans ce menu. Les bricolages préconisés dépendent de la calculatrice :
Pour La Ti et la Numworks, chaque méthode de l’objet Variable est une fonction ayant un homonyme vu comme variable globale. Par exemple
def augmente_toi_de():
pass
Alors en entrant le nom d’une variable Sofus puis le point, il suffit de naviguer dans le menu des variables pour ajouter le texte .augmente_toi_de() dans lequel il suffit d’insérer l’incrément.
Pour la Casio et la Numworks, on peut afficher le nom des variables et naviguer dans cet affichage puis faire du copier-coller pour rapidement avoir le texte dans la console Python.
Pour entrer le texte pourcents ou a_la_puissance (ou au_carre ou au_cube), la Ti et la Numworks facilitent le travail, puisque ce sont des nomns de variables, auxquelles on accède par le bouton « var » ou « vars ».
Pour la Casio, les textes pourcents etc sont affichés au lancement de Sofus et il faut naviguer dans cet affichage pour le copier-coller dans la console.
Le texte Variable() permettant de facilement créer des variables dans Sofus, est affiché au lancement de Sofus, ce qui permet, sur Casio ou Numworks, de copier-coller ce texte dans la console [2].
Pour faire la comparaison entre les calculatrices, on va traiter un exemple simple : Un prix initialement fixé à 100 €, augmente puis diminue de 5 pourcents, et on souhaite connaître sa valeur finale.
Une fois lancée l’application PyAdaptr ou Python, on devrait voir quelque part dans la liste des programmes présents, le module SOFUS. On l’exécute, ce qui a pour effet de démarrer une console Python avec exécution automatique de
from SOFUS import *
On entre alors prix (soit en naviguant dans les caractères sur une sorte de clavier virtuel, soit en appuyant sur les boutons [2nde] et [alpha]) puis (après avoir le cas échéant quitté le mode alpha) on appuie sur le bouton [sto→] et on continue avec le texte Variable (attention à l’initiale en majuscule) et les parenthèses entre lesquelles on va entrer 100. Cette étape est plus longue qu’avec les autres calculatrices mais on ne l’effectue qu’une fois.
Après avoir appuyé sur le bouton [entrer] on peut utiliser la flèche vers le haut pour retrouver la ligne précédente et effacer (avec [suppr]) le signe « = » et tout ce qui le suit. On appuie ensuite sur le bouton avec un point (tout en bas du clavier) et le bouton [var] dans lequel on repère augmente_toi_de() que l’on sélectionne. On appuie alors sur le bouton 5 du clavier puis la virgule, et on retourne dans les variables (avec appui sur [var]) pour sélectionner pourcents. On devrait avoir prix.augmente_toi_de(5,pourcents)
Après avoir appuyé sur [entrer] le prix a augmenté de 5 pourcents. On peut s’en assurer si on le souhaite en entrant prix (comme ci-dessus). Mais une fois qu’on a l’affichage prix on peut aussi appuyer à nouveau sur la touche avec un point puis [var] pour naviguer vers diminue_toi_de() à sélectionner, puis entre parenthèses 5 puis la virgule puis pourcents en naviguant dans les variables. Ce qui devrait aboutir assez rapidement à prix.diminue_toi_de(5,pourcents)
Après appui sur [entrer] la valeur finale du prix peut être connue en retrouvant prix dans l’historique (flèche vers le haut) puis [entrer]. On a alors l’affichage 99.75000000000001 à interpréter comme 99,75 €.
Depuis le menu des applications (bouton [menu]) on choisit Python puis, parmi les programmes Python disponibles, on navigue jusqu’à sofus.py et on lance ce programme (avec [run]). Ceci a pour effet d’afficher plein de choses dans la console. On n’a plus qu’à choisir parmi ces plein de choses et copier-coller :
L’appui successif sur les boutons [shift] puis [alpha] puis [f5] (qui échange les majuscules et les minuscules) puis les touches « p », « r », « i » et « x » donne l’affichage prix ; ensuite on appuie deux fois sur [shift] pour quitter le mode alpha et on appuie sur [shift] puis [=] pour transformer l’affichage en prix=. Ensuite on appuie sur la flèche vers le haut jusqu’à mettre en exergue Variable() qu’on sélectionne. Il ne reste alors plus qu’à placer 100 entre les parenthèses avec les touches du clavier pour avoir prix=Variable(100) à exécuter.
Ensuite, on remonte avec la flèche du haut (une seule fois) pour retrouver l’affichage prix=Variable(100) tel qu’il était avant l’exécution. Le bouton [del] permet d’effacer le signe « = » et ce qui le suit pour n’avoir que prix, à faire suivre du point (touche du bas) et une fois qu’on a prix. on remonte avec la flèche du haut jusqu’à mettre en exergue augmente_toi_de que l’on sélectionne par appui sur [exe] pour avoir prix.augmente_toi_de à compléter avec les boutons du clavier (parenthèse ouvrante puis 5 puis virgule puis [shift] puis [alpha] puis les lettres de pourcents puis [shift] et encore [shift] et parenthèse fermante). On a alors prix.augmente_toi_de(5,pourcents) et il suffit d’appuyer sur [exe] pour effectuer l’augmentation.
Ensuite on peut appuyer une fois sur la flèche du haut et [exe] pour recopier cette ligne (sans l’exécuter) dans la console. Ensuite on peut effacer le texte entre le point et la parenthèse ouvrante (appui successif sur [del]) et là, on remonte avec la flèche vers le haut jusqu’à diminue_toi_de pour retrouver rapidement prix.diminue_toi_de(5,pourcents). La touche [exe] permet d’effectuer la diminution.
En remontant dans l’historique jusqu’à une ligne commençant par prix et en effaçant au besoin ce qui suit prix on peut faire prix [exe] qui affiche la valeur finale du prix, soit 99.75000000000001 à interpréter comme 99,75 €.
Une fois qu’on a lancé l’application Python, on descend (avec la flèche vers le bas) jusqu’à la « console d’exécution » puis appui sur [exe], ce qui démarre la console avec (entre autres) from sofus import *.
Pour créer la variable prix on appuie deux fois (pour verrouiller) sur le bouton [alpha] puis lettre par lettre on entre prix. Un nouvel appui sur alpha permet de quitter le mode alpha. On appuie alors sur [shift] puis [π] pour avoir prix= puis là, avec la flèche vers le haut, on remonte jusqu’à l’affichage Variable() que l’on sélectionne avec appui sur [exe] pour avoir prix=Variable() où il suffit d’insérer 100 avec les touches numériques du clavier. Après appui sur [exe] la variable est initialisée.
En remontant avec la flèche vers le haut on recopie la ligne prix=Variable(100) telle qu’elle était avant exécution ; là on peut effacer le « = » et ce qui le suit, puis en appuyant sur le bouton [var] on trouve augmente_toi_de() que l’on sélectionne par appui sur [exe] pour avoir prix.augmente_toi_de() à compléter, d’abord en entrant 5 au clavier, puis la virgule, il suffit de répéter la manip précédente (bouton [var] puis navigation jusqu’à pourcents et appui sur [exe]) pour avoir la ligne prix.augmente_toi_de(5,pourcents)
Après appui sur [exe] le prix a augmenté de 5 pourcents. On peut s’en assurer en remontant avec la flèche vers le haut puis en effaçant tout ce qui est après prix puis [exe] ce qui affiche 105.0 comme prévu. Ensuite, pour effectuer la diminution, on remonte dans l’historique jusqu’à une ligne commençant par prix et le cas échéant on efface tout ce qui est après prix. Puis on ajoute un point, on navigue dans les variables jusqu’à diminue_toi_de() que l’on insère (avec [exe]) derrière le point, pour ensuite remplir les parenthèses avec 5 et la virgule (au clavier) puis le mot pourcents (avec le bouton [var] puis le choix de pourcents à insérer avec [exe]). Ceci donne prix.diminue_toi_de(5,pourcents)
Après avoir appuyé sur [exe] on peut afficher la valeur finale du prix en remontant dans l’historique jusqu’à une ligne commençant par prix et après avoir éventuellement effacé de cette ligne tout ce qui n’est pas prix, appui sur [exe]. Ceci donne le même affichage 99.75000000000001 que les autres calculatrices.
Pour ce qui est de l’ergonomie, la Numworks passe devant la Ti (dont l’historique ne permet de parcourir que les commandes et pas les affichages) qui elle-même passe devant la Casio (bouton [var] inopérant).
Voici comment Simon Viète calculait des valeurs approchées de π :
c = Variable(0)
p = Variable(1)
for n in range(40):
c.augmente_toi_de(1)
c.divise_toi_par(2)
c.eleve_toi(a_la_puissance(0.5))
p.multiplie_toi_par(c.valeur)
p.inverse_toi()
p.double_toi()
print(p)
L’incrément d’une variable est loin d’être spécifique de Sofus (même Scratch permet cela). Dans Sofus, le verbe incrémenter sous-entend que l’incrément est 1, mais dans χCAS, l’incrément est à donner entre parenthèses, après le nom de la variable. De même, des équivalents pour les 3 autres opérations ont été fournis, y compris sous la forme de néologismes :
Version Sofus
Équivalent χCAS
v.augmente_toi_de(5)
increment(v,5)
v.diminue_toi_de(5)
decrement(v,5)
v.multiplie_toi_par(5)
multcrement(v,5)
v.divise_toi_par(5)
divcrement(v,5)
L’avantage de χCAS sur Sofus est qu’il n’est pas nécessaire de passer par la programmation objet et les variables spécifiques de Sofus : Toute variable Python peut être incrémentée, décrémentée, multcrémentée ou divcrémentée en χCAS, ce qui permet de refaire les scripts sans pourcentages assez rapidement avec χCAS [3]. Par exemple :
Nombres triangulaires :
0=>S
for N in range(8): increment(S,N)
24 dés
0=>S
for N in range(24): increment(S,randint(1,6))
puissances de 2
1=>P
for K in range(8): multcrement(P,2)
factorielle
1=>P
for K in range(1,11): multcrement(P,K)
Outre le fait que χCAS ne permet pas d’augmenter, diminuer etc d’un pourcentage, il lui manque les mots doubler, inverser etc pour être aussi naturel que Sofus.
Par contre, avec Sofus en Python, si on veut faire aussi du calcul formel, il faut utiliser, en plus, le module SymPy.
Et χCAS permet aussi d’explorer un petit programme en mode pas-à-pas, ce qui est d’une grande aide à l’apprentissage de la programmation.
Enfin, il y a une autre syntaxe dans χCAS plus proche de la programmation objet de Sofus en Python ; par exemple au lieu de increment(v,3) on peut écrire v.increment(3) qui est très proche de la notation objet de Sofus en Python.
[1] ou plutôt sa valeur ; on remarque que, dans la théorie des actions de groupe, il est d’usage de noter x.f au lieu de f(x) l’image de x par f, et ce n’est peut-être pas un hasard si c’est la même notation que dans la programmation objet : Les méthodes d’un objet x peuvent être vues comme des fonctions agissant sur x
[2] Sur Ti il est nécessaire d’écrire au clavier Variable(), à moins de modifier Sofus pour que par exemple il y soit ajouté une variable (de Python) appelée Variable1 et initialisée à none ; dans ce cas il suffit après avoir navigué jusqu’à Variable1 dans le menu des variables, d’effacer le « 1 » et de le remplacer par les parenthèses entre lesquelles on place la valeur initiale de la variable Sofus.
[3] avec l’avantage supplémentaire que permet le calcul formel, notamment pour les preuves de programmes de calcul
Dans un site très personnel, Olivier Sicard nous offres quelques « délires » de mathématiques, algorithmique et programmation. Entre autres pépites, on découvrira le Rubix-Tore, la loi normale asymétrique, la théorie du choix social et le dessin à l’aide des séries de Fourier.
Après Elwyn Berlekamp l’année dernière, c’est au tour du centenaire Richard Guy et de l’immense John Conway. Ce document de Richard Guy (une mise en garde contre le raisonnement inductif) montre bien le style unique de son auteur, en plus d’être une mine de ressources pour des exercices. Conway, outre son jeu de la vie, a créé des dizaines de jeux, dont Sprouts, très populaire dès le CP.
On sait bien que Nicolas Bourbaki n’était pas le nom d’une personne mais le pseudonyme d’un groupe. L’équivalent en informatique théorique est Claude Livercy, auteur de la théorie des programmes. Roger Mohr était un des membres de Claude Livercy.
Quand les chercheurs mettent au point des modèles d’optimisation et de recherche de plus court chemin qui s’inspirent du comportement de masse de colonies de fourmis...
À écouter : Sur les Épaules de Darwin, émission diffusée sur France Inter samedi 31 août 2013.
Les RMLLd se dérouleront pour la 2e fois à Saint-Joseph du 22 au 25 août.
C’est une opportunité pour les élèves qui suivent la spécialité ISN et les passionnés d’informatique.
Commentaires