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
Zip - 468 octets
Zip - 572 octets

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():pass

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

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 :

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

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.

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

  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)

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 π :

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

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

Annonces

Prochains rendez-vous de l’IREM

Assemblée générale de l’APMEP-Réunion

- Mercredi 21 aout à 14h, lycée Évariste-de-Parny, saint-Paul.

Réunion de rentrée de l’IREM

- Mercredi 11 septembre 2019, 14h-18h, salle S23.6, PTU, Saint-Denis.


Brèves

Python au bac 2019

vendredi 31 mai

C’est une brève de MathemaTICE

La question 4b de l’exercice 3 du bac S Amérique du Nord ne pouvait être résolue sans utiliser Python.

Elwyn Berlekamp

jeudi 18 avril

Elwyn Berlekamp, connu des lecteurs de ce site pour son jeu des interrupteurs, était un spécialiste du jeu de Go ainsi que de la Pipopipette, d’Édouard Lucas que Berlekamp admirait énormément.

Notation au bac

lundi 11 décembre 2017

Une nouvelle notation sera pratiquée à partir de la session 2018 pour les algorithmes au bac. Elle est décrite avec de nombreux exemples, ici.

Décès de Roger Mohr

mardi 27 juin 2017

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.

À travers les labyrinthes : algorithmes et fourmis

dimanche 1er septembre 2013

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.

Rencontres Mondiales du Logiciel Libre à St-Joseph

mardi 20 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.

Voici pour le samedi et le dimanche quelques interventions choisies :
- http://2013.d.rmll.info/Raspberry-votre-ordinateur-au-format-carte-de-credit?lang=fr
- http://2013.d.rmll.info/Materiel-libre-et-DIY?lang=fr
- http://2013.d.rmll.info/Arduino-de-l-electronique-libre?lang=fr

Noter aussi les conférences Art et Culture du dimanche, ainsi qu’une conférence plus engagée.

Le programme complet se trouve ici. Une radio sera ouverte pour l’occasion.
Des plaquettes à distribuer se trouvent ici.

Hyper-vidéos pour l’algorithmique au lycée

dimanche 19 août 2012

Olivier Roizès, à la demande de l’ADIREM, a réalisé une collection d’hyper-vidéos de présentation de logiciels et environnements de programmation. Ces hyper-vidéos, c’est-à-dire des vidéos contenant des éléments clicables, devraient être utiles aux enseignants désireux de se familiariser avec Python, CaRMetal, R, Rurple, Scilab ou Xcas.

Ouverture du SILO

mardi 1er novembre 2011

Le SILO (Science Informatique au Lycée : Oui !) est un espace collaboratif documentaire de partage et de formation collégiale, à destination des professeurs appelés à enseigner l’informatique au lycée.

Une initiative du CNDP, de l’INRIA et de Pasc@line, à laquelle se sont associés SPECIF, fuscia, EPI et ePrep.

Sur le Web : Site du SILO

Introduction à la science informatique

lundi 12 septembre 2011

Le CRDP de Paris publie le premier ouvrage destiné aux professeurs chargés d’enseigner la nouvelle spécialité « Informatique et sciences du numérique » en Terminale S à la rentrée 2012. Cet ouvrage a été coordonné par Gilles Dowek, directeur de recherche à l’INRIA.

Sur la création de la spécialité ISN, on pourra également consulter l’interview donnée au Café pédagogique par l’inspecteur général Robert Cabanne.

Sur le Web : CRDP de Paris

Deux publications sur l’algorithmique

samedi 17 octobre 2009

L’IREM d’Aix-Marseille publie une brochure de 73 pages, téléchargeable librement, intitulée Algorithmes et logique au lycée. Ces notions sont illustrées et déclinées sur des exercices du programme de spécialité mathématique en série L, mais sont adaptables aux programmes à venir.

Le hors série thématique n° 37 du magazine Tangente, disponible actuellement en kiosque, s’intitule « Les algorithmes. Au cœur du raisonnement structuré ». Extrait de l’éditorial : « La rédaction de Tangente a conçu la quasi-totalité de ce hors série thématique pour qu’il puisse être lu par des élèves de Seconde ».

Statistiques

Dernière mise à jour

dimanche 14 juillet 2019

Publication

844 Articles
Aucun album photo
140 Brèves
11 Sites Web
145 Auteurs

Visites

476 aujourd'hui
451 hier
2894294 depuis le début
23 visiteurs actuellement connectés