Aujourd'hui Golden Man rend hommage au mathématicien britannique John Horton Conway qui nous a hélas quittés le 11 avril 2020, emporté par l'épidémie de Covid-19.
Retrouve donc dès maintenant sur ta NumWorks son célèbre jeu de la vie en Python.
L'état initial est aléatoire donc n'hésite pas à relancer plusieurs fois et peut-être obtiendras-tu des choses remarquables comme des oscillateurs, vaisseaux, mathusalems, ou même si tu es chanceux∙se puffeurs, canons, jardins d’Éden ou spacefillers.
Golden Man te propose de plus le choix entre deux versions utilisant des grilles différentes :
En ce jour de fête nationale, NumWorks met à profit les formidables possibilités Python de sa calculatrice pour t'animer ses bons vœux.
Et puis n'hésite pas à aller consulter la publication officielle, NumWorks te propose en effet de gagner un assortiment de formages La Box Fromage pour fêter l'occasion.
NumWorks nous sort la nouvelle version 14 pour sa calculatrice. Plus précisément il s'agit de la version 14.4.0 et nous allons découvrir ensemble les nouveautés apportées :
Commençons par l'application Calculs qui bénéficie d'améliorations notables.
L'affichage de l'historique de calcul avait le défaut de perdre beaucoup de place en affichant systématiquement le résultat en-dessous de l'expression saisie. Dans certains cas c'était à peine si tu pouvais visualiser plus d'un calcul à l'écran sans avoir à faire défiler.
Désormais lorsque possible, le résultat sera affiché sur la même ligne que l'expression saisie, pour une bien meilleure vue d'ensemble de ton travail !
Une fonctionnalité demandée depuis longtemps par la communauté et justement implémentée dans plusieurs firmwares tiers, dorénavant plus besoin de s'embêter à installer un firmware tiers pour ça !
En cours de saisie, tu avais la possibilité avec la touche
↑
d'aller chercher des éléments dans ton historique de calcul, afin de les intégrer à ton expression.
Toutefois, la touche
↑
sert également pour la navigation au sein de l'expression naturelle en cours de saisie.
Or, l'élément récupéré était systématiquement inséré à la dernière position du curseur. Pour les expressions s'affichant en empilant plusieurs niveaux (quotients, puissances, ...), seul le niveau supérieur pouvait donc recevoir l'élément récupéré, puisque c'était le dernier par lequel était passé ton curseur. Impossible notamment de récupérer quelque chose au dénominateur d'un quotient.
La dernière version permet maintenant enfin de récupérer des éléments de l'historique de calcul à n'importe quel endroit d'une expression en cours de saisie !
Lorsque donc tu tapes
↑
pour aller chercher un élément dans l'historique de calcul, les éventuelles zones de l'expression en cours de saisie par lesquels ton curseur ne fait que traverser en un temps très court ne sont maintenant plus retenues comme position d'insertion.
Depuis la dernière version ta NumWorks disposait d'une formidable nouveauté, la gestion des calculs utilisant des unités.
L'unité du résultat était choisi automatiquement par la calculatrice, selon ce qu'elle jugeait être le plus pertinent.
Mais voilà, contrairement à toi ta calculatrice ne disposait pas du contexte du problème, et ne faisait donc pas toujours le meilleur choix.
Tu te devais donc à chaque fois de demander manuellement une conversion vers l'unité souhaitée, avec pas mal de touches à presser.
Dans la nouvelle version, il y a mieux.
Lorsque tu remontes dans l'historique de calcul, sur les résultats utilisant des unités tu as maintenant la possibilité de demander d'une simple touche des résultats complémentaires. Et ces résultats complémentaires utilisent justement d'autres unités jugées pertinentes par la calculatrice.
La NumWorks parlait jusqu'à présent 5 langues différentes, langues que tu pouvais choisir dans l'application Paramètres :
Anglais
Français
Espagnol
Allemand
Portugais
Avec cette nouvelle version, pas moins de 2 langues supplémentaires sont au menu :
Néerlandais
Italien
Ce n'est pas une surprise dans le contexte tout récent de l'acceptation de la NumWorks sur les listes officielles de modèles autorisés aux examens aux Pays-Bas et en Italie, c'était la moindre des choses.
Quand au mode examen, il continue à offrir 2 choix lorsque la calculatrice est en anglais ou maintenant également néerlandais :
mode examen dit international (celui proposé par défaut dans toutes les autres langues dont le français : ne fait qu'effacer la mémoire)
mode examen néerlandais (interdit en prime l'utilisation de l'application Python, la réglementation des Pays-Bas interdisant l'accès pendant l'épreuve à tout éditeur de texte)
Jusqu'à présent lorsque l'on effectuait des calculs de lois de probabilités selon une distribution géométrique, l'on n'obtenait bizarrement pas les mêmes résultats que sur les autres calculatrices graphiques. Tous les autres modèles suffisamment capables désapprouvaient même à l'unison :
Ce n'était pas que la calculatrice avait faux, c'était qu'elle n'utilisait pas la même définition que les autres modèles.
C'est corrigé, la nouvelle version utilise bien à partir de maintenant la définition de loi géométrique du contexte scolaire.
Dans l'application Régressions, tu pouvais tester l'adéquation de tes données avec pas moins de 9 modèles différents :
linéaire :
$mathjax$y = a x + b$mathjax$
quadratique :
$mathjax$y = a x ^ 2 + b x + c$mathjax$
cubique :
$mathjax$y = a x ^ 3 + b x ^ 2 + c x + d$mathjax$
quartique :
$mathjax$y = a x ^ 4 + b x ^ 3 + c x ^ 2 + d x + e$mathjax$
logarithmique :
$mathjax$y = a \ln \left( x \right) + b$mathjax$
exponentielle :
$mathjax$y = a e ^ { b x }$mathjax$
puissance :
$mathjax$y = a x ^ b$mathjax$
trigonométrique :
$mathjax$y = a \sin \left( b x + c \right) + d$mathjax$
logistique :
$mathjax$y = \frac { c } { 1 + a e ^ { - b x } }$mathjax$
Mais aucune n'était adaptée à une situation très simple connue depuis le collège, la proportionnalité des grandeurs (
$mathjax$y = a x$mathjax$
).
Tu pouvais choisir la régression linéaire et donc la proportionnalité des accroissements, pour un résultat pas toujours proche de ce que tu attendais et donc difficilement exploitable.
La nouvelle version accueille donc à cette fin une nouvelle régression dite proportionnelle.
Un modèle cette fois-ci parfaitement adapté à l'étude de l'adéquation à une situation de proportionnalité des grandeurs.
L'application Python passe dès maintenant sur la nouvelle version 1.12 de MicroPython.
La NumWorks devient de plus le premier modèle à disposer d'un assistant d'aide à la saisie Python !
Il prend la forme d'une fonctionnalité d'auto-complétion, une exclusivité sur calculatrices Python à ce jour. Mais c'est bien plus creusé que ce que tu pourrais croire, il y a un véritable assistant d'aide à la saisie derrière.
A peine commences-tu à taper un nom de fonction ou variable dans l'éditeur Python, que la calculatrice est désormais capable de te faire une suggestion, affichée en grisé directement au sein de l'éditeur. Si la suggestion te convient, tu peux alors la valider d'une seule touche en tapant
OK
ou
→
.
Et si jamais la suggestion ne te convient pas, tu peux soit poursuivre ta saisie avec les caractères suivant en espérant mieux, soit demander de suite d'autres suggestions d'une simple touche,
Nous avions noté il y a quelques semaines à l'occasion de la sortie d'un module similaire chez Casio, quelques points faibles du module Pythonturtle de la NumWorks par rapport au standard :
absence de la fonction write() permettant d'écrire du texte à la position de la tortue
absence de la fonction colormode() permettant de choisir l'unité de coordonnées couleur RGB (nombres flottants entre 0 et 1, ou nombres entiers entre 0 et 255), pour compatibilité avec les scripts conçus pour des plateformes n'ayant pas fait le même choix par défaut (Casio et justement le standard sur ordinateur).
appels circle(r) avec un paramètre de rayon r négatif pour inverser le sens de tracé ignorés
Nous avons le plaisir de voir que ces détails ont tous été soigneusement traités et corrigés !
Repassons un petit peu maintenant sur la conformité au standard du module turtle de la NumWorks, et donc sa compatibilité avec les scripts disponibles dans les livres ou en ligne.
Commençons déjà par tester les déplacements relatifs de la tortue. Voici par exemple avec la construction d'une rosace par rotation d'un polygone régulier :
def rosap(n1=12, n2=8, l=30): d1, d2 = 360//n1, 360//n2 for i in range(n1): left(d1) for i in range(n2): forward(l) left(d2)
speed(0) rosap()
La tortue travaillant en pixels, le code aurait besoin d'être adapté pour l'écran Graph 35+E II à plus faible définition. Mais à part cela, le code passe ici sans problème sur Casio, NumWorks et ordinateur.
Complexifions un petit peu la chose avec la fractale de Koch. Rajoutons également un levé de crayon (penup), un déplacement absolu (goto), ainsi que l'utilisation d'une des couleurs prédéfinies :
for i in range(1,37): red=(exp(-0.5 * ((i-6)/12)**2)) green=(exp(-0.5 * ((i-18)/12)**2)) blue=(exp(-0.5 * ((i-30)/12)**2)) pencolor([red, green, blue]) for i in range(1, 5): forward(60) right(90) right(10)
Problème ici sur NumWorks, qui a fait le choix de ne pas utiliser le même système de coordonnées que le standard pour les composantes de couleurs RVB :
nombres flottants de 0.0 à 1.0 sur Casio et ordinateur
nombres entiers de 0 à 255 sur NumWorks et TI-83 Premium CE Edition Python
Mais nous disposons donc sur NumWorks de la nouvelle fonction colormode() pour choisir le système de coordonnées. Il suffira donc tout simplement de rajouter un appel colormode(1.) à tout script compatible Casio ou ordinateur pour le rendre également fonctionnel sur NumWorks !
Par contre, chez Casio cette fonction certes inutile ici n'est pas présente. Il nous faut donc sécuriser son appel en interceptant toute erreur éventuelle.
for i in range(1,37): red=(exp(-0.5 * ((i-6)/12)**2)) green=(exp(-0.5 * ((i-18)/12)**2)) blue=(exp(-0.5 * ((i-30)/12)**2)) pencolor([red, green, blue]) for i in range(1, 5): forward(60) right(90) right(10)
Poursuivons avec une coquille d'escargot en appliquant la même astuce, et l'appel à la fonction de tracé de cercle circle() :
Petit écart chez Casio, avec le texte qui est écrit en prenant la position de la tortue comme coin supérieur gauche, alors que le standard la prend comme coin inférieur gauche.
Passons maintenant au script de démo dédié à la Casio Graph 90+E, avec inversion du sens de tracé des cercles.
Il suffisait pour cela de passer un rayon négatif à la fonction circle(), ce qui n'était hélas pas géré chez NumWorks et ignoré.
def sierp(n, l): if n == 0: for i in range (0, 3): fd(l) left(120) if n > 0: sierp(n-1, l/2) fd(l/2) sierp(n-1, l/2) bk(l/2) left(60) fd(l/2) right(60) sierp(n-1, l/2) left(60) bk(l/2) right(60)
Une implémentation du module turtle hautement fidèle, en excellent adéquation avec le standard sur cette série d'exemples !
La NumWorks nous apparaît ainsi clairement comme la solution nomade la plus facile à utiliser en pratique en classe dans le contexte du module turtle; c'est a priori celle où l'on rencontrera le moins d'incidents avec les scripts conçus pour d'autres plateformes fournis par les livres ou Internet.
De même, nous avions noté il y a quelques semaines lors de la sortie d'un module similaire chez Casio, quelques points faibles avec le module Pythonmatplotlib.pyplot de la NumWorks par rapport au standard :
impossibilité d'afficher un diagramme vide
erreur en cas de précision d'un paramètre de couleur pour les tracés de diagrammes
erreur en cas de précision du paramètre de forme pour les tracés de points
erreur en cas de précision du paramètre nommé de taille pour les tracés de flèches ou vecteurs
Et ici de même, ce que nous avons évoqué semble avoir été traité. ! Plus d'erreur de syntaxe donc quand tu réutilises des scripts conçus pour d'autres plateformes !
Les paramètres de couleurs sont donc désormais acceptés et fonctionnels, conformément au standard :
paramètres de couleur optionnels (fonction plot)
paramètres de couleur nommés (fonctions scatter, bar, hist, et arrow)
Testons donc maintenant la conformité au standard de matplotl.pyplot, et donc par conséquent sa compatibilité avec les scripts conçus pour d'autres plateformes.
Commençons déjà avec les fonctions de base, comme axis() pour régler les bornes de la fenêtre graphique, même si ce n'est pas obligatoire et qu'elles s'adapteront par défaut au contenu affiché :
try: from matplotlib.pyplot import * except ImportError: from matplotl import *
text(0.4,0.9,"TITRE") show()
Petit écart, on remarque que la NumWorks opte pour une graduation sur les axes, alors que les autres plateformes utilisent une graduation en bordure de fenêtre.
Démarrons maintenant avec de petits diagrammes en barres via la fonction bar() :
Ici nous travaillons donc non pas sur des pixels mais des coordonnées, ce qui permet à la Casio Graph 35+E II de nous produire un affichage correct malgré un écran très inférieur à la concurrence.
Très léger détail, notons que la NumWorks n'utilise pas la même couleur de barre par défaut que les autres plateformes couleur, y compris l'ordinateur.
Passons maintenant à des nuages de points à l'aide de la fonction scatter() :
try: from matplotlib.pyplot import * except ImportError: from matplotl import *
x = [100, 110, 120, 130, 140, 150, 160] y = [105, 95, 75, 68, 53, 46, 31]
scatter(x, y) axis([80, 170, 10, 130]) text(110, 125, "Nombre d'acheteurs vs prix de vente") show()
On apprécie le style de point par défaut conforme au standard (ordinateur) sur la NumWorks, contraitement à chez Casio.
On apprécie également d'avoir cette fois-ci désormais la bonne couleur de point par défaut.
Par contre, petit problème de positionnement de texte sur la NumWorks. Au lieu d'utiliser comme les autres les coordonnées fournies comme coin supérieur gauche du texte affiché, elle les utilise apparemment comme coin inférieur gauche... Précisons toutefois que la NumWorks compense cela par une possibilité formidable, celle de faire défiler la fenêtre graphique en cours d'affichage à l'aide des flèches du clavier comme sur ordinateur, ce qui n'est pas possible sur les calculatrices concurrentes !
Passons maintenant à quelques diagrammes en ligne brisée et à la fonction plot() :
try: from matplotlib.pyplot import * except ImportError: from matplotl import *
def fonction(): def f(x): return x**3-6*x**2+9*x+1 start = -0.5 end = 4.5 steps = 0.1 x = [start+i*steps for i in range(int((end-start)/steps)+1)] y = [f(j) for j in x] plot(x, y) show()
try: from matplotlib.pyplot import * except ImportError: from matplotl import *
plot([1,5,7],[8,12,10],"magenta") show()
Tiens, surprise, après une première tentative pourtant encourageante nous obtenons une erreur avec pourtant le même genre d'appel.
Ce n'est donc pas que le paramètre de couleur n'est pas géré, mais que le nom de couleur fourni à la deuxième tentative, ici "magenta" soir pourtant une couleur de base, est inconnu de la NumWorks.
Ne disposant pas du module matplotlib.colors, on peut tester bêtement toutes les couleurs standard à l'aide du script suivant afin de savoir ce qu'il en retourne :
def colors(): ltcolors = [] axis((0, sw - 1, 0, sh - 1)) axis('off') for c in lcolors: try: plot(0, 0, c) print(c) ltcolors.append(c) except: pass
ncols = floor(len(ltcolors)**.5) nlines = ceil(len(ltcolors)**.5) if ncols * nlines < len(ltcolors): ncols += 1 lineh = sh // (nlines + 1) colw = sw // (ncols + .5) x, y = colw / 2, sh - 1 - lineh
for c in ltcolors: plot((x, x + colw / 2), (y, y), c) text(x, y, c) y -= lineh if y<=0: y = sh - 1 - lineh x += colw
print(len(ltcolors)) show() return ltcolors
Effectivement, si la NumWorks reconnaît 18 noms de couleurs prédéfinies soit un petit peu plus que la concurrence, elle souffre encore de quelques manques parmi les couleurs de base :
Casio
NumWorks
black / k white / w red / r yellow / y green / g blue / b cyan / c magenta . . . .
black / k white / w red / r yellow / y green / g blue / b cyan grey brown orange purple pink
Aille, ici encore un problème sur la NumWorks qui accepte certes désormais le 3ème argument de la fonction plot() pour la forme des points, mais en refuse la valeur "+".
Testons de façon similaire tous les styles de point standard à l'aide du script suivant afin de savoir ce qui est géré ou pas :
try: from matplotlib.pyplot import * except ImportError: from matplotl import *
Val=[1,2,2,11,8,9,15,18,20,9,2,5,6,7,8,9,5,9]
boxplot(Val) show()
Et histoire d'avoir des diagrammes en boîte correctement affchés dans le cadre de l'enseignement français, Casio rajoute en prime au standard avec la fonction boxplotFR() :
Hélas, la fonction boxplot() n'est toujours pas incluse chez NumWorks.
Contrairement au module turtle précédent, matplotlib.pyplot est encore incomplet et souffre également de quelques petits écarts ou bugs. La conformité au standard n'en est pas au même point, et matplotlib.pyplot à la différence ne permet donc pas encore de pouvoir lancer les yeux fermés les scripts fournis dans les livres ou récupérés sur Internet.
Il n'empêche que l'implémentation déjà réalisée de matplotlib.pyplot est un travail titanesque et qu'elle a en prime beaucoup progressé depuis la version précédente.
Notre ressenti est donc globalement très positif; NumWorks est en très bonne voie, et nous espérons pouvoir continuer à noter des progrès dans la prochaine version.
Les interpréteurs MicroPython ou similaires qui tournent sur ta calculatrice font appel à 3 types de mémoires avec les rôles suivants :
la mémoire de stockage qui accueille et conserve tes scripts
le stack (pile) qui, à l'exécution, accueille les références vers les objets créés
le heap (tas) qui, à l'exécution, accueille les valeurs de ces objets
En gros le stack / pile limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap / tas limite la taille globale occupé par ces objets.
La mémoire de stockage est toujours de 32 Kio.
Une façon de mesurer maintenant la capacité de stack / pile de façon relative c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons le script suivant :
def sizeenv(): s=0 import __main__ for o in dir(__main__): try:s+=size(eval(o)) except:pass return s def size(o): s,t=0,type(o) if t==str:s=49+len(o) if str(t)=="<class 'function'>":s=136 if t==int: s=24 while o: s+=4 o>>=30 if t==list: s+=64 for so in o:s+=8+size(so) return s def mem(v=1,r=1): try: l=[] try: l+=[r and 793+sizeenv()] if v*r:print(" ",l[0]) l+=[0] l+=[""] l[2]+="x" while 1: try:l[2]+=l[2][l[1]:] except: if l[1]<len(l[2])-1:l[1]=len(l[2])-1 else:raise(Exception) except: if v:print("+",size(l)) try:l[0]+=size(l) except:pass try:l[0]+=mem(v,0) except:pass return l[0] except:return 0
Pas de changement notable ici, l'appel mem() continue à renvoyer dans les 32 Ko.
Puisque nous avons donc une toute nouvelle version MicroPython ainsi que de nouvelles fonctions dans certains modules, petit bilan en passant au sujet de la richesse des solutions Python sur calculatrices. Nous explorons les modules avec le script explmod.py :
def getplatform(): id=-1 try: import sys try: if sys.platform=='nspire':id=0 if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4 except:id=3 except: try: import kandinsky id=1 except: try: if chr(256)==chr(0):id=5+(not ("HP" in version())) except: id=2 return id
platform=getplatform() #lines shown on screen #plines=[29,12, 7, 9,11,0,0] plines=[29,16, 7, 9,11,0,0] #max chars per line #(error or CR if exceeded) pcols =[53,99,509,32,32,0,0]
if platform>=0: curline=0 _p = print nlines=plines[platform] ncols=pcols[platform] def print(*ls): global curline st="" for s in ls: if not(isinstance(s,str)): s=str(s) st=st+s stlines=1+int(len(st)/ncols) if curline+stlines>=nlines: input("Input to continue:") curline=0 _p(st) curline+=stlines
def sstr(obj): try: s=obj.__name__ except: s=str(obj) a=s.find("'") b=s.rfind("'") if a>=0 and b!=a: s=s[a+1:b] return s
def isExplorable(obj): for k in done: try: if isinstance(obj, eval(k)): t, done[k] = done[k], True return not t except: pass if str(obj).startswith("<module"): return False l = () try: l = dir(obj) except: pass return len(l)
def explmod(pitm, pitmsl=[], reset=True): global curline spitm=sstr(pitm) if(reset): curline=0 pitmsl=[spitm] for k in done: done[k] = False hd="."*(len(pitmsl)-1) c,c2=0,0 l = sorted(dir(pitm)) for i in range(len(l)): l[i] = (l[i], getattr(pitm, l[i])) try: if not isinstanceof(pitm, str): for i in range(len(pitm)): l.append((spitm+'['+str(i)+']',pitm[i])) except: pass for itm in l: c,c2=c+1,c2+1 isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform] try: if isUnsafe: raise Exception print(hd+itm[0]+"="+str(itm[1])) except: print(hd+itm[0]) if not isUnsafe and isExplorable(itm[1]) and itm[1] != pitm and itm[0] not in pitmsl: pitmsl2=pitmsl.copy() pitmsl2.append(itm[0]) c2=c2+explmod(itm[1], pitmsl2, False)[1] if c>0 and reset: print(hd+"Total: "+str(c)+" 1st level item(s)") if c2>0 and c2!=c: print(hd+" "+str(c2)+" item(s)") return [c,c2]
NumWorks nous signe donc aujourd'hui une superbe mise à jour avec des progrès très significatifs pour l'utilisateur et l'enseignement en classe !
Des avancées majeures dans les applications Calculs et Python, et de superbes améliorations et extensions des modules turtle et matplotlib.pyplot de cette dernière.
Visiblement NumWorks tient compte en un temps record et dans les moindres détails de toutes les critiques bienveillantes que nous pouvons publier.
Et tout cela comme d'habitude disponible gratuitement, que demander de plus ?
Petit alerte toutefois, le firmwareNumWorks en version 14 est nettement plus gros que la version précédente, avec pas moins de 921,6 Kio. Ce n'est absolument pas problématique pour la NumWorks N0110 distribuée à partir de la rentrée 2019 avec ses 8 Mio de Flash.
Nous sommes toutefois de plus en plus inquiets pour la NumWorks N0100 originale sortie pour la rentrée 2017. Ses 1 Mio de Flash sont donc maintenant occupés par le dernier firmware à plus de 90%.
Si les améliorations continuent au même rythme, d'ici quelques versions il deviendra impossible de faire tout rentrer sur NumWorks N0100...
Le constructeur va visiblement devoir prendre de grandes décisions assez rapidement...
En 1982, Jean-François Sehan diffuse un jeu de Saute Mouton pour l'ordinateur monochrome Sinclair ZX81 dans son livre Etudes pour ZX 81(tome 1) aux éditions PSI.
Dès juillet 1983, J. Michels en sort une très belle adaptation couleur pour ordinateurs Thomson MO5/TO7.
Plantons d'abord le décor ! A gauche 3 moutons maigres dans leur bergerie. A droite 3 moutons gras dans le pâturage. Il faut rentrer les moutons gras dans la bergerie et faire arriver les moutons maigres au pâturage. Comment faire ? Les moutons ne peuvent sauter qu'un seul mouton à la fois and ne peuvent reculer. Amuse-toi bien !!!
Nous sommes donc ici en 320×200 pixels, et comme nombre de jeux des années 1980 cela se prête donc bien à adaptation pour calculatrices graphiques couleur actuelles n'est-ce pas ?
Dans un actualité précédente, nous t'en sortions une adaptation Python pour TI-83 Premium CE Edition Python, avec des graphismes nettement améliorés qui transcendaient les années 1980.
Près de 9 secondes pour planter un décor aussi complexe, pas mal du tout pour la puissance assez limitée de cette machine.
Par la suite nous te sortions une autre adaptation Python pour Casio Graph 90+E.
Plus que dans les 8,5 secondes pour planter le décor, ce qui était ici assez décevant pour une machine beaucoup plus puissante que la précédente.
Voici enfin aujourd'hui notre version Python pour NumWorks.
Le jeu se lance en appelant sm().
Sur la dernière NumWorks N0110 le décor initial est ici planté bien plus rapidement en à peine 5 secondes, ce qui est d'autant plus remarquable que contrairement à la TI-83 Premium CE Edition Python l'on ne bénéficie pas ici de routines optimisées pour afficher des primitives !
Les performances sont tellement extraordinaires que pour les rafraîchissements d'écran lors des sélections et déplacements de moutons, nous avons dû rajouter une instruction pour ralentir la calculatrice sinon c'était totalement injouable !
Une fois que tu auras réussi avec les 2 troupeaux de 3 moutons par défaut, n'hésite pas à aller plus loin en appelant sm(n) pour 2 troupeaux de n moutons.
En tous cas avec de telles performances, il est fort étrange que les jeux Python offrant des interfaces avec sprites graphiques soient encore l'exception sur la NumWorks, au profit de jeux affichant et déplaçant des caractères ou formes très élémentaires...
La calculatrice NumWorks est également disponible sous la forme d'applications pour Android et iPhone / iPad.
Ces applications bénéficient maintenant de mises à jour te permettant de retrouver sur ton smartphone ou ta tablette toutes les superbes améliorations apportées à la calculatrice par la version 14.4.0, notamment au niveau des applications Calculs et Python.
Pour l'application Android la chose va même un tout petit peu plus loin, puisqu'elle passe en fait en version 14.4.1.
by 
Je nais de 3 mais puis me sustenter de 2...
Golden Man te propose de plus le choix entre deux versions utilisant des grilles différentes :
