Page 1 of 1

Exploration module Python ce_quivr TI-83 Premium CE 5.5

Unread postPosted: 20 May 2020, 11:06
by critor
12382Dans 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, y compris avec un clavier USB externe !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
    • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
    • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  • 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

Nous disposons aujourd'hui enfin de ces 4 modules complémentaires et nous proposons de commencer à t'analyser.
Attention, ces modules ne sont apparemment pas inclus dans la mise à jour et seront à charger séparément.

Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen. :#non#:

Explorons maintenant plus en profondeur ce_quivr pour les diagrammes utilisant des champs de vecteurs.




Sommaire :




1) importation et taille ce_quivr

Go to top

Une fois le fichier ce_quivr.8xv chargé dans la calculatrice, à première vue aucun changement.

ce_quivr n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.

ce_quivr n'apparaît pas non plus dans la liste des modules disponibles.

Mais pas grave, tentons quand même notre première importation de ce_quivr.

A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.
Code: Select all
from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Comme tu peux voir, la consommation de tas est significative, le module ce_quivr fait 8,832 Ko. Il nous reste maintenant moins de 8 Ko de heap Python disponible, on ne va pas pouvoir coder des monuments... :#roll#:

On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
  • qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
  • ti_plotlib importe à son tour le module sys (224 o)
  • ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
  • ti_graphics importe également le module sys (224 o)
  • ti_graphics import aussi le module math (336 o)
Donc en contrepartie de cette consommation de heap, tu aurais déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre. :bj:




2) menus ce_quivr

Go to top

Le module ce_quivr n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.

En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.




3) exemples ce_quivr

Go to top

Le programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
  • nuages de points
  • histogrammes
  • positions successives d'un système modélisé par un point
  • vecteurs vitesse associés à chacun de ces points

Nous avions déjà vu que la possibilité de tracer des nuages de points était couverte par le nouveau module Python ti_plotlib.
Pour les diagrammes permettant l'étude du mouvement d'un système ponctuel, et plus généralement la représentation de diagrammes utilisant des champs de vecteurs, c'est donc ce_quivr qui s'en occupe.


Découvrons cela de suite à travers quelques exemples.

Voici pour étudier un mouvement rectiligne qui semble alors uniformément accéléré :
Code: Select all
import ti_plotlib as plt
from ti_system import *
from ce_quivr imort *

#Les fonctions
def calc_vitesses(absc, temps):
  v = []
  for n in range(len(absc) - 1):
    v.append((absc[n + 1] - absc[n]) / (temps[n + 1] - temps[n]))
  temps = temps[:-1]
  return v, temps

def rep_vitesses(absc, vitesses):
  for i in range(len(vitesses)):
  quiver(absc[i], 0, vitesses[i], 0, 0.06, "b", "vector")

#Le programme
plt.cls()
plt.title("Etude du MRUA")
plt.window(-0.2, 1.2, -1, 1)
x = recall_list("2")
t = recall_list("1")
v, temps_v = calc_vitesses(x, t)
rep_vitesses(x, v)
plt.show_plot()


Et maintenant pour l'étude d'un mouvement à une dimension sur un axe :
Code: Select all
import ti_plotlib as plt
from ce_quivr import *

fx = lambda x: x**3 - 4*x**2 + 3*x - 2
dx = lambda x: 3*x**2 - 8*x + 3
d2x = lambda x: 6*x - 8

def motion(min, max, n):
  dt = (max-min) / n
  t = min
  for i in range(n):
    quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line')
    if i % 7 == 0:
      quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector')
      quiver(t, fx(t), 0, d2x(t), .4, 'b')
    t += dt

plt.window(-.25, 4, -5, 7)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes('on')
plt.labels('Time', '   X Position     ', 7, 3)
motion(0, 4, 49)
plt.show_plot()




4) exploration ce_quivr

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ce_quivr, à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E

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]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

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)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

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


Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_quivr, ici 1.0.

On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_quivr et accessible via ce_quivr.plt.

Le module ce_quivr offre donc 5 éléments au premier niveau, et jusqu'à 41 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
.
.
97-1581
3-363
.
13-428
9-404
42-602
.
.
10-410
.
.
17-977
.
.
25-1277
89-211
.
.
12-34
.
41-63
3-25
11-33
6-28
.
9-31
.
3-25
38-60
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042267-701315-772

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 123-302 éléments : Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
69-126
.
91-230
2-28
.
12-38
7-33
41-67
.
.
6-32
.
8-34
12-38
.
.
24-108
93-218
2-28
.
12-38
7-33
41-67
.
.
3-29
.
.
15-86
.
.
.
92-212
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
93-214
2-25
2-25
12-35
7-30
41-64
.
.
6-29
15-38
8-31
15-99
8-33
.
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28
matplotl:25-68
nsp:3-10board:22
storage:7-47
ce_box:5-32
ce_chart:?
ce_quivr:5-41
ce_turtl:?
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules69891317
Eléments217-496203-608176-509158-488238-692325-845

Classement en terme de richesse :
  1. 325-845 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 158-488 éléments : TI-83 Premium CE + TI-Python

Tuto-vidéos :