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 :
pourcents = "pourcents"
au_carre = 2
au_cube = 3
def a_la_puissance(n): return n
class Variable():
def __init__(self,v):
self.valeur = float(v)
def __str__(self):
return str(self.valeur)
def __repr__(self):
return str(self.valeur)
def augmente_toi_de(self,d=1,mode=None):
if mode == pourcents:
self.valeur *= 1+d/100
else:
self.valeur += d
def diminue_toi_de(self,d=1,mode=None):
if mode == pourcents:
self.valeur *= 1-d/100
else:
self.valeur -= d
def multiplie_toi_par(self,d=2,mode=None):
if mode == pourcents:
self.valeur *= d/100
else:
self.valeur *= d
def divise_toi_par(self,d=2,mode=None):
if mode == pourcents:
self.valeur /= d/100
else:
self.valeur /= d
def eleve_toi(self,p=au_carre):
self.valeur **= p
def inverse_toi(self):
self.valeur = 1/self.valeur
def double_toi(self):
self.valeur *= 2
def triple_toi(self):
self.valeur *= 3
def decuple_toi(self):
self.valeur *= 10
print("Variable()")
def augmente_toi_de(): pass
def diminue_toi_de(): pass
def multiplie_toi_par(): pass
def divise_toi_par(): pass
def eleve_toi(): pass
def inverse_toi(): pass
def double_toi(): pass
def triple_toi(): pass
def decuple_toi():passUn 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 :
S = Variable(0)
for n in range(9): S.augmente_toi_de(n)
SÀ titre de comparaison, voici la version Python :
S = 0
for n in range(9): S+=n
S
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) :
from random import *
S = Variable(0)
for _ in range(24): S.augmente_toi_de(randint(1,6))
S2**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.
p = Variable(1)
for n in range(9): p.double_toi(); print(p)
nombre d’or
Il y a quelque chose de magique dans ce script :
o = Variable(1)
for _ in range(9): o.inverse_toi(); o.augmente_toi_de(1); print(o)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
from sofus import *
adultes = Variable(1)
jeunes = Variable(1)
for n in range(9):
naissances = adultes.valeur
adultes.augmente_toi_de(jeunes.valeur)
jeunes = Variable(naissances)
print(adultes)Voici les choix de modélisation qui ont été faits sur ce problème de lapins :
- Comme on a besoin de Sofus, on importe son contenu
- Initialement il y a un lapin adulte, le nombre d’adultes vaut donc 1
- et il y a un lapereau qui ne donnera pas naissance tout de suite
- On itère sur 9 générations ; à chaque génération :
- Chaque adulte donne un lapereau, il y a donc autant de naissances que d’adultes ;
- les anciens jeunes deviennent adultes, ce qui augmente (dangereusement) la population d’adultes
- les nouveaux-nés deviennent des lapereaux
- on affiche le nombre d’adultes pour vérifier le modèle.
pi
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)Factorielle
p = Variable(1)
for k in range(1,11): p.multiplie_toi_par(k);print(k,p)
Spirale
Si la tortue avance d’un pas décroissant d’un pourcentage constant, elle dessine une spirale logarithmique :
from Sofus import *
from turtle import *
p = Variable(10)
for _ in range(36): fd(p.valeur);lt(15);p.diminue_toi_de(5,pourcents)
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 :
from sofus import *
def integrale(f,a,b):
dx = 0.0001
x = Variable(a)
S = Variable(0)
while x.valeur < b:
S.augmente_toi_de(f(x.valeur)*dx)
x.augmente_toi_de(dx)
return S.valeur
Commentaires