Sofus sur calculatrices, grâce à Python

Le portage du code source de Sofus en Python permet de programmer en Sofus sur calculatrices et de modéliser la notion de variable
jeudi 9 mai 2019
par  Alain BUSSER

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.

Installation de Sofus sur la calculatrice

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 :

Voici le script à télécharger directement :

  1. pourcents = "pourcents"
  2. au_carre = 2
  3. au_cube = 3
  4. def a_la_puissance(n): return n
  5.  
  6. class Variable():
  7.     def __init__(self,v):
  8.         self.valeur = float(v)
  9.     def __str__(self):
  10.         return str(self.valeur)
  11.     def __repr__(self):
  12.         return str(self.valeur)
  13.     def augmente_toi_de(self,d=1,mode=None):
  14.         if mode == pourcents:
  15.             self.valeur *= 1+d/100
  16.         else:
  17.             self.valeur += d
  18.     def diminue_toi_de(self,d=1,mode=None):
  19.         if mode == pourcents:
  20.             self.valeur *= 1-d/100
  21.         else:
  22.             self.valeur -= d
  23.     def multiplie_toi_par(self,d=2,mode=None):
  24.         if mode == pourcents:
  25.             self.valeur *= d/100
  26.         else:
  27.             self.valeur *= d
  28.     def divise_toi_par(self,d=2,mode=None):
  29.         if mode == pourcents:
  30.             self.valeur /= d/100
  31.         else:
  32.             self.valeur /= d
  33.     def eleve_toi(self,p=au_carre):
  34.         self.valeur **= p
  35.     def inverse_toi(self):
  36.         self.valeur = 1/self.valeur
  37.     def double_toi(self):
  38.         self.valeur *= 2
  39.     def triple_toi(self):
  40.         self.valeur *= 3
  41.     def decuple_toi(self):
  42.         self.valeur *= 10
  43.  
  44. print("Variable()")
  45. def augmente_toi_de(): pass
  46. def diminue_toi_de(): pass
  47. def multiplie_toi_par(): pass
  48. def divise_toi_par(): pass
  49. def eleve_toi(): pass
  50. def inverse_toi(): pass
  51. def double_toi(): pass
  52. def triple_toi(): pass
  53. def decuple_toi():pass

Télécharger

Programmation objet

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 invese_toi() (avec des parenthèses vides parce que c’est la syntaxe des méthodes d’un objet)

Les classes en classe

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

prix = Variable(8)

C’est quoi une variable ?

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.

Usage des calculatrices

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
    1. def augmente_toi_de():
    2.      pass

    Télécharger

    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.

Un exemple

pourcentages

Pour savoir quel est l’effet d’une augmentation de 5% suivie d’une diminution de 5%, on se propose de faire cette expérience :

  • On crée une variable Sofus appelée prix et on initialise cette variable à 100 ;
  • on augmente prix de 5 pourcents
  • on diminue prix de 5 pourcents
  • on affiche la valeur finale de prix

Les onglets suivants montrent comment faire avec chaque calculatrice, supposée munie de Sofus en Python.

Ti 83 Premium CE

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 €.

Casio

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 €.

Numworks

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).

Exemples

Voici quelques exemples de programmes en Sofus, version calculatrices :

  • Somme des entiers successifs
  • Lancer de 24 dés
  • puissances de 2
  • approximations du nombre d’Or
  • suite de Fibonacci
  • calcul de π par Viète
  • factorielle
  • spirale logarithmique
  • méthode des rectangles

nombres triangulaires

Pour calculer la somme 1+2+3+...+8, on va créer une variable S que l’on va augmenter de 1, puis de 2, puis de 3, etc :

  1. S = Variable(0)
  2. for n in range(9): S.augmente_toi_de(n)
  3. S

Télécharger

À titre de comparaison, voici la version Python :

  1. S = 0
  2. for n in range(9): S+=n
  3. S

Télécharger

Remarque : La fonction d’agrégation sum permet d’avoir le résultat en une seule ligne :

sum(range(9))

24 dés

Même principe que pour les nombres triangulaires, mais cette fois-ci S augmente du résultat d’un lancer de dé, donné par randint(1,6) :

  1. from random import *
  2. S = Variable(0)
  3. for _ in range(24): S.augmente_toi_de(randint(1,6))
  4. S

Télécharger

2**n

Pour calculer les puissances de 2, il suffit de savoir que

  • 20=1
  • chaque puissance de 2 est le double de la précédente

On utilise donc la commande double_toi() de façon répétitive pour calculer des puissances de 2.

  1. p = Variable(1)
  2. for n in range(9): p.double_toi(); print(p)

Télécharger

nombre d’or

Il y a quelque chose de magique dans ce script :

  1. o = Variable(1)
  2. for _ in range(9): o.inverse_toi(); o.augmente_toi_de(1); print(o)

Télécharger

Il donne effectivement des valeurs approchées du nombre d’or :

Fibonacci

Le script est un peu plus long que les précédents, on peut donc envisager de le placer dans un module appelé fibo.py et contenant

  1. from sofus import *
  2. adultes = Variable(1)
  3. jeunes = Variable(1)
  4. for n in range(9):
  5.     naissances = adultes.valeur
  6.     adultes.augmente_toi_de(jeunes.valeur)
  7.     jeunes = Variable(naissances)
  8.     print(adultes)

Télécharger

Voici les choix de modélisation qui ont été faits sur ce problème de lapins :

  1. Comme on a besoin de Sofus, on importe son contenu
  2. Initialement il y a un lapin adulte, le nombre d’adultes vaut donc 1
  3. et il y a un lapereau qui ne donnera pas naissance tout de suite
  4. On itère sur 9 générations ; à chaque génération :
  5. Chaque adulte donne un lapereau, il y a donc autant de naissances que d’adultes ;
  6. les anciens jeunes deviennent adultes, ce qui augmente (dangereusement) la population d’adultes
  7. les nouveaux-nés deviennent des lapereaux
  8. on affiche le nombre d’adultes pour vérifier le modèle.

pi

Voici comment Simon Viète calculait des valeurs approchées de π :

  1. c = Variable(0)
  2. p = Variable(1)
  3. for n in range(40):
  4.     c.augmente_toi_de(1)
  5.     c.divise_toi_par(2)
  6.     c.eleve_toi(a_la_puissance(0.5))
  7.     p.multiplie_toi_par(c.valeur)
  8. p.inverse_toi()
  9. p.double_toi()
  10. print(p)

Télécharger

Factorielle

  1. p = Variable(1)
  2. for k in range(1,11): p.multiplie_toi_par(k);print(k,p)

Télécharger

Spirale

Si la tortue avance d’un pas décroissant d’un pourcentage constant, elle dessine une spirale logarithmique :

  1. from Sofus import *
  2. from turtle import *
  3. p = Variable(10)
  4. for _ in range(36): fd(p.valeur);lt(15);p.diminue_toi_de(5,pourcents)

Télécharger

intégrale

Pour calculer l’intégrale de f entre a et b par la méthode des rectangles, on peut mettre cette fonction dans un module :

  1. from sofus import *
  2. def integrale(f,a,b):
  3.     dx = 0.0001
  4.     x = Variable(a)
  5.     S = Variable(0)
  6.     while x.valeur < b:
  7.         S.augmente_toi_de(f(x.valeur)*dx)
  8.         x.augmente_toi_de(dx)
  9.     return S.valeur

Télécharger

Le cas khiCAS

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.


[1ou 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

[2Sur 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.

[3avec l’avantage supplémentaire que permet le calcul formel, notamment pour les preuves de programmes de calcul


Commentaires