WARNING ! For those who have a TI-83 Premium CE or a TI-84 Plus CE (Python Edition or not), think very carefully before updating to OS 5.5/5.6.
While there are lots of Python-related improvements, this version removes ASM support. Most games, and some programs, will not work anymore.
est sortie pour la rentrée 2017 et a été distribuée jusqu'en 2018-2019.
Elle est construite autour d'une puce
ASIC STM32F412
.
Or problème, la
STM32F412
ne propose que
1 Mio
soit
1024 Kio
de mémoire
Flash
pour accueillir le
firmware
, une capacité qui est en voie d'être épuisée.
La dernière version constructeur
Epsilon 14.4.0
par exemple occupe
922,1 Kio
, soit
90,04%
.
L'avant-dernière version tierce
Omega 1.19.2
, un
firmware
rajoutant justement nombre de fonctionnalités, occupait quant à elle
981,3 Kio
, soit déjà
95,83%
.
Dans sa dernière version,
Omega 1.20.2
utilise certes une astuce pour réduire nettement sa taille à moins de
887,9 Kio
soit
86,81%
. Il n'y a plus qu'une seule langue incluse au lieu de 8, langue dont le choix t'est proposé à l'installation.
C'est un léger mieux qui évite certes le drame cette fois-ci, mais cela ne change pas radicalement le problème. On ne peut plus rajouter grand chose de conséquent sur
NumWorks N0100
, que ce soit avec
Epsilon
ou
Omega
.
La
NumWorks N0100
dispose toutefois d'un emplacement pour accueillir une puce
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 ?
, 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...
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.
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.
, 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.
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,
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 :
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
, 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
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)
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
Python
matplotlib.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 :
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
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()
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 :
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
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]
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.
Trônant tel un vaisseau spatial dans l'espace intersidéral, ta
NumWorks
, bien évidemment équipée de son
firmware
de combat
Omega
, peut maintenant être orientée à ta volonté pour une visibilité optimale de son écran !
Une toute nouvelle dimension à la simulation
NumWorks
avec beaucoup de potentiel; peut-être de quoi pouvoir enfin charger des scripts comme en vrai à l'aide du port micro-USB, ou encore la débloquer à l'aide du bouton reset sans avoir à recharger la page... comme en vrai quoi !
WARNING ! For those who have a TI-83 Premium CE or a TI-84 Plus CE (Python Edition or not), think very carefully before updating to OS 5.5/5.6.
Or problème, la 
La 
