Dans sa prochaine mise à jour
5.5 gratuite prévue pour
Mai 2020,
Texas Instruments va rajouter de
formidables possibilités historiques à ta
TI-83 Premium CE :
- mise à jour en 5.5 de l'application SciTools
- mise à jour en 5.5 de l'application Periodic
- mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)
Python 5.5 offre de nouveaux modules intégrés pour tes scripts
Python :
- time, certes déjà présent mais maintenant listé au menu et donc officiel
- ti_system, avec diverses possibilités :
- détection des simples pressions de touches clavier (sans validation donc) par l'utilisateur, avec même l'éventuel modificateur actif (
2nde
ou alpha
), et ça marche aussi avec un clavier USB ! - affichage dans la console à la ligne que tu veux
- exportation de listes de nombres (entiers, flottants ou complexes) existant dans le contexte Python vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications
- importation depuis le contexte Python de listes ou équation de régression existant dans l'environnement de la calculatrice
- et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice, enfin l'application Python va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité !
- ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
- nuage de points
- diagramme en ligne brisée
- droite de régression linéaire
- ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
- ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
- ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car
Python 5.5 gère également la possibilité inédite de rajouter des modules
Python complémentaires :
- ce_turtl, comparable à turtle
- ce_box pour les diagrammes en boîte
- ce_chart pour les histogrammes et aires entre courbes
- ce_quivr pour les diagrammes utilisant des champs de vecteurs
Aujourd'hui nous poursuivons notre exploration du module complémentaire
ce_turtl, donc voici enfin ci-dessous le détail des menus :
Comme tu peux le voir, nous disposons à priori de tout ce qu'il faut pour une faire aussi bien qu'avec le module
turtle standard.
Le module
ce_turtl semble comporter lui-même un sous-module
turtle.
Une même script pourrait même tourner a priori aussi bien avec
ce_turtl que le
turtle standard sur ordinateur, à condition de tenir compte de tout cela à l'importation. Nous pouvons faire au choix :
- Code: Select all
try: from ce_turtl.turtle import *
except ImportError: from turtle import *
- Code: Select all
try: from ce_turtl import *
except ImportError: import turtle
Notons que la saisie via les menus
ce_turtl préfixe toutes les commandes d'un
turtle. et n'est donc adaptée qu'à ce dernier point.
Nous allons donc maintenant tester la compatibilité de
ce_turtl avec les solutions concurrentes, ainsi que sa conformité au standard
turtle.
Précisons que nous ne disposons pas à ce jour du fichier permettant de rajouter ce_turtl à la calculatrice, et sommes donc limités aux exemples fournis par Texas Instruments.Pour cela nous allons commencer doucement en y allant fonction par fonction, avant d'aborder des exemples plus poussés.
Démarrons donc avec un tracé de polygone tout simple:
- Code: Select all
try: from ce_turtl import *
except ImportError: import turtle
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
polyg(100,4)
Ainsi que tu peux voir, comme avec
ti_plotlib et
ti_graphics, les tracés
ce_turtl sont effectués directement sur l'écran d'affichage de la console
Python.
D'où la nécessité de commencer par effacer l'écran avec ici non pas le
turtle.clearscreen() standard, mais
turtle.clear().
De plus, comme les affichages sortent sur la console, ils sont nettoyés et perdus dès que ton script rend la main. Il faut donc insérer une boucle d'attente en fin de script, ici fournie par l'appel non standard
turtle.show(). Contrairement à ce que son nom indique, cette fonction n'affiche rien par elle-même et ne fait qu'attendre l'appui sur une touche d'interruption par l'utilisateur. Elle est donc équivalente aux appels
ti_plotlib.show_plot() et
ti_system.disp_wait(), ainsi qu'au code suivante :
- Code: Select all
while not ti_system.escape():
pass
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
polyg(100,4)
try: turtle.show()
except: pass
|
Mettons maintenant de la couleur, par exemple du bleu. Et voici les ennuis de compatibilité arriver.
Déjà, les différentes plateformes n'utilisent même pas les mêmes systèmes de coordonnées pour les composantes RVB de couleurs :
- nombre flottant de 0.0 à 1.0 sur Casio et ordinateur
- nombre entier de 0 à 255 sur NumWorks et TI-83 Premium CE Edition Python
De plus, le standard
turtle offre deux fonctions pour régler la couleur :
- turtle.pencolor() qui contrôle la couleur du stylo, ici absente sur TI-83 Premium CE Edition Python
- turtle.color() qui règle à la fois la couleur du stylo et du pinceau (remplissage), absente cette fois-ci chez Casio
On pourrait penser régler proprement et définitivement ce dernier problème de compatibilité dès l'importation pour n'avoir plus rien à faire par la suite, en rajoutant la fonction manquante. Si l'on importe directement le contenu de
turtle, on peut faire :
- Code: Select all
try:
from ce_turtl.turtle import *
pencolor = color
except ImportError:
from turtle import *
try:
color
except:
color = pencolor
Mais traitons maintenant du cas d'importation adapté à la saisie via les menus; on pourrait faire :
- Code: Select all
try:
from ce_turtl import *
ce_turtl.pencolor = ce_turtl.color
except ImportError:
import turtle
try:
turtle.color
except:
turtle.color = turtle.pencolor
Ce dernier code marche parfaitement sur
Casio et sur ordi
(standard), mais hélas pas sur
NumWorks qui refuse à la différence que l'on rajoute après importation une fonction à un module.
Tant pis, le code de compatibilité sera donc moins propre en attendant que l'on trouve mieux.
Nous réglerons de plus l'épaisseur de crayon à 1.
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
|  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
polyg(100,4)
try: turtle.show()
except: pass
|
Autre divergence ici sur
TI-83 Premium CE Edition Python, où le
turtle.pensize(1) produit des traits de plus d'1 pixel d'épaisseur contrairement à toutes les autres plateformes.
Tentons maintenant de commencer le tracé ailleurs :
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
polyg(100,4)
try: turtle.show()
except: pass
|
Recommençons maintenant en levant le stylo afin d'éviter le tracé parasite au départ :
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
turtle.penup()
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
turtle.pendown()
polyg(100,4)
try: turtle.show()
except: pass
|
Passons maintenant à un hexagone :
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def polyg(l,n):
for i in range(n):
turtle.forward(l)
turtle.left(360/n)
turtle.penup()
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
turtle.pendown()
polyg(100,6)
try: turtle.show()
except: pass
|
Voici maintenant les
flocons de Koch :
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def koch(n, l):
if n<=0:
turtle.forward(l)
else:
koch(n-1, l/3)
turtle.left(60)
koch(n-1, l/3)
turtle.right(120)
koch(n-1, l/3)
turtle.left(60)
koch(n-1, l/3)
def flock(n, l):
koch(n, l)
turtle.right(120)
koch(n, l)
turtle.right(120)
koch(n, l)
l=80
turtle.penup()
turtle.goto(105,3)
turtle.left(120)
turtle.pendown()
my_turtle_pencolor((0, 0, 0))
flock(3, l)
turtle.left(120)
turtle.penup()
turtle.goto(105,-10)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((255, 127, 0))
flock(4, l)
turtle.right(60)
turtle.pensize(1)
turtle.penup()
turtle.goto(5,45)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((0, 0, 255))
flock(2, l)
turtle.right(60)
turtle.penup()
turtle.goto(-100,17)
turtle.left(120)
turtle.pendown()
my_turtle_pencolor((255, 0, 0))
flock(0, l)
turtle.left(120)
turtle.pensize(2)
turtle.penup()
turtle.goto(-100,-5)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((0, 255, 0))
flock(1, l)
turtle.right(60)
turtle.penup()
turtle.forward(400)
try: turtle.show()
except: pass
|
Evidemment, le code utilisant les paramètres
turtle.pensize() non standard de la
TI-83 Premium CE Edition Python, il ne produit pas le même effet sur la concurrence.
Notons toutefois en passant que les réglages
turtle.pensize() semblent totalement ignorés chez
Casio.
Et maintenant les
triangles de Sierpiński :
Graph
35+E II | Graph
90+E | TI-83 Premium CE
Edition Python | Num
Works | ordi |
 |  |  |  |  |
- Code: Select all
try:
from ce_turtl import *
turtle.clear()
except ImportError: import turtle
def my_turtle_pencolor(t):
cmax = 255
try:
turtle.pencolor((0,0,0))
fc = turtle.pencolor
except:
fc = turtle.color
try: fc((2,2,2))
except: cmax = 1
if(cmax == 1 and max(t)>1):
t = tuple(u/255 for u in t)
elif(cmax == 255 and any(isinstance(u, float) for u in t)):
t=tuple(int(255*u) for u in t)
fc(t)
def sierp(n, l):
if n == 0:
for i in range (0, 3):
turtle.fd(l)
turtle.left(120)
if n > 0:
sierp(n-1, l/2)
turtle.fd(l/2)
sierp(n-1, l/2)
turtle.bk(l/2)
turtle.left(60)
turtle.fd(l/2)
turtle.right(60)
sierp(n-1, l/2)
turtle.left(60)
turtle.bk(l/2)
turtle.right(60)
turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
my_turtle_pencolor((255, 0, 0))
sierp(6, 217)
turtle.penup()
turtle.forward(400)
try: turtle.show()
except: pass
|
Bien que non parfaite, les bibliothèques turtle de Casio et NumWorks jouissaient d'une très bonne conformité au standard, ce qui permettait quasiment sans aucune modification d'utiliser les mêmes scripts turtle sur ces modèles différents.
Ici avec ce_turtle sur TI-83 Premium CE Edition Python la compatibilité semble nettement inférieure, et le nombre à gérer de cas particuliers connus à ce jour suffisamment important. A priori une bibliothèque compatibilité turtle va donc malgré tout être nécessaire si l'on souhaite que les scripts turtle standard qui tournent déjà sur Casio/NumWorks puissent également fonctionner sur TI-83 Premium CE Edition Python, et inversement.
by 
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments rajoute de formidables possibilités historiques à la TI-83 Premium CE, et en profite pour répondre à ces divers besoins.
Et bien non, Texas Instruments n'a rien laissé de côté, les besoins en histogrammes sont quant à eux couverts par le module complémentaire ce_chart dont voici les menus ci-contre.
Mais ce n'est pas tout, Texas Instruments a également eu la bonne idée d'exposer la fonction interne de tracé de rectangle servant pour les barres d'histogramme dans un 2nd onglet de menu.
Une application par exemple en Mathématiques, c'est l'approche de l'aire entre deux courbes par la méthode des rectangles. Et la fonction draw_fx() est justement là pour compléter le tracé avec la courbe en question.
