

Il s'agit plus précisément d'une version
Cette mise à jour apporte une grande nouveauté, une application

- Editeur et modèles de scripts
- 1er script et console - nombres flottants et complexes
- Modules importables et modules standard
- Saisie et assistant d'aide à la saisie
- Mémoire pile/stack
- Mémoire tas/heap
- Module sys - implementation et entiers
- Module ti_system - intégration, clavier et souris
- Module de tracé par pixels ti_draw
- Module de tracé par pixels ti_image
- Module de tracé par pixels ti_picture
- Bilan modules
- Performances en virgule flottante
- Performances en calcul entier
- Conclusion
1) Editeur et modèles de script :
Go to top- éditeur de script (nouveau ou ouvrir)
- console (shell)
Commençons donc par l'éditeur avec un nouveau script. Afin de pouvoir démarrer très vite dans nombre de situations au lycée,
- Code: Select all
# Math Calculations
#================================
from math import *
#================================
- Code: Select all
# Random Simulations
#================================
from math import *
from random import *
#================================
- Code: Select all
# Geometry Graphics
#================================
from ti_draw import *
#================================
- Code: Select all
# Image Processing
#================================
from ti_image import *
from ti_draw import get_screen_dim
#================================
- Code: Select all
# Plotting (x,y) & Text
#================================
import ti_plotlib as plt
#================================
plt.window(,,,)
plt.grid(1,1,"dotted")
plt.axes("on")
- Code: Select all
# Data Sharing
#================================
from ti_system import *
#================================
- Code: Select all
# Hub Project
#================================
from ti_hub import *
from math import *
from time import sleep
from ti_plotlib import text_at,cls
from ti_system import get_key
#================================
- Code: Select all
# Rover Coding
#================================
import ti_rover as rv
from math import *
import ti_plotlib as plt
from ti_system import *
from time import *
#================================

Il bénéficie de la coloration syntaxique, de l'indentation automatique, peut afficher simultanément jusqu'à 11 lignes, et le numéro de la ligne courante étant reporté en haut à droite, fort utile pour corriger les éventuelles erreurs d'exécution.


shiftcomme sur ordinateur, couper-copier-coller-effacer la sélection courante à l'aide des racourcis
ctrl
X,
ctrl
C,
ctrl
Vet
del. La touche
menudonnera accès à d'autres fonctionnalités tout en en rappelant les raccourcis clavier : aller en début/fin de ligne, en début/fin de script, aller à un numéro de ligne, rechercher, remplacer.

Gros avantage par rapport à la concurrence, on y trouve également un vérificateur syntaxique qui te permettra de gagner du temps en anticipant nombre d'erreurs qui t'auraient embêté(e) à l'exécution. En prime contrairement aux erreurs d'exécution dans la console

2) 1er script et console - nombres flottants et complexes :
Go to topCommençons par les nombres en virgule flottante dits flottants. Ce type de donnée utile pour les nombres non entiers sous la forme
- M, un nombre entier relatif dit mantisse
- Emin, nombre entier négatif indique l'exposant minimal pouvant être codé
- E, nombre entier naturel codant l'exposant
Voici donc nos toutes premières fonctions
- Code: Select all
def precm(b):
k,b=0,float(b)
while 1+b**-k-1>0:
k+=1
return k
def prece():
a=-1
while 2.**a>0:
a*=2
while 2.**a==0:
a+=1
b=1
while str(2.**b)[0:3]!='inf':
b*=2
while str(2.**b)[0:3]=='inf':
b-=1
return [a,b]



Mais on peut également utiliser la touche
menupour demander directement l'exécution du script depuis l'éditeur, auquel cas ce dernier sera importé automatiquement.
Notons la touche
varqui te permet de lister et saisir rapidement les noms de fonctions et variables globales définies dans le script.
L'appel
precm(2)
nous répond que le moteur travaille en virgule flottante avec des mantisses dont la précision est codée sur precm(10)
)L'appel
prece()
nous indique pour sa part que les valeurs codables pour les exposants dans la formule vont de Il s'agit du standard double précison du
Notons au passage avec la saisie
1j
la gestion des nombres complexes dits imaginaires 3) Modules importables et modules standard :
Go to top


La touche
menunous donne alors un accès très rapide à une sélection de différentes fonctions
Outre le module
- math
- randompour les fonctions aléatoires
- ti_plotlib, module de tracé par coordonnées
- ti_hubpour les projets d'objets connectés avec l'interfaceTI-Innovator Hub
- ti_roverpour les projets de robotique avec le robotTI-Innovator Rover

- cmathpour les fonctions relatives aux nombres imaginaires/complexes(Option Maths Expertes + série STI2D)
- time
- ti_system
- ti_draw, module de tracé par pixels
- ti_image, autre module de tracé par pixels

help('modules')
.Nous obtenons alors une liste qui n'est pas complète, reprenant certains des modules précédents mais pas tous. Par contre, elle nous en annonce d'autres que voici :
- array
- binascii
- collections
- ctypes
- errno
- gc
- hashlib
- heapq
- micropython
- re
- sys
- ti_picture
- ti_st
Commençons par traiter les modules
La solution

TI- 83PCE TI- Python | TI- 83PCE Edition Python | TI- 84+CE-T Python Edition | TI- Nspire CX II | Casio Graph 90+E 35+E II | Num Works | ||||||||
builtins array (u)binascii board cmath (u)collections (u)ctypes (u)errno gc (u)hashlib (u)heapq (u)io (u)json linalg math matplotlib .pyplot micropython numpy os (u)random (u)re storage (u)struct sys time (u)timeq turtle (u)zlib TOTAL | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8 | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8 | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8 | ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . . . ✓ . . ✓ . . ✓ ✓ . . ✓ ✓ . . . 16 | ✓ . . . . . . . . . . . . . ✓ . ✓ . . . ✓ . . . . . . ✓ . 3- 5 | ✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . . ✓ . . . . ✓ . ✓ . 9 | ✓ ✓ . . ✓ . . ✓ ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 8 | ✓ ✓ . ✓ ✓ ✓ . . ✓ . . . . . ✓ . . ✓ . ✓ ✓ . ✓ . ✓ ✓ . . . 13 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 7 | ✓ . ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ 23 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . ✓ . . . ✓ . . . . 8 | ✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . ✓ ✓ . . . . ✓ . ✓ . 10 | ✓ . ✓ . ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . ✓ ✓ ✓ 23 |
Passons maintenant aux modules propriétaires lorsque disponibles :
TI- 83PCE Edition Python | TI- 84+CE-T Python Edition | TI- Nspire CX II | Casio Graph 90+E 35+E II | Num Works | |||||
analogin analogout bbport brightns ce_box ce_chart ce_quivr ce_turtl color colorinp conservo dht digital led light lightlvl loudness magnetic mb_butns mb_disp mb_grove mb_music mb_neopx mb_pins mb_radio mb_sensr microbit moisture potentio power ranger relay rgb rgb_arr sound squarewv temperat thermist ti_graphics ti_hub ti_plotlib ti_rover ti_system speaker timer vernier vibmotor | analogin analogout bbport brightns ce_box ce_chart ce_quivr ce_turtl color colorinp conservo dht digital led light lightlvl loudness magnetic mb_butns mb_disp mb_grove mb_music mb_neopx mb_pins mb_radio mb_sensr microbit moisture potentio power ranger relay rgb rgb_arr sound squarewv temperat thermist ti_graphics ti_hub ti_plotlib ti_rover ti_system speaker timer vernier vibmotor | ti_draw ti_hub ti_image ti_innovator ti_picture ti_plotlib ti_rover ti_st ti_system | casioplot | ion kandinsky | prime | nsp | arit cas graphic nsp | ion kandinsky | arit cas graphic nsp |
34- 47 | 47 | 9 | 1 | 2 | 1 | 1 | 4 | 2 | 4 |
Il ne nous semble pas pertinent de baser un classement comparatif sur les modules propriétaires, un unique module sur un modèle haut de gamme pouvant apparemment être éclaté en plein de petits modules différents sur un modèle disposant de moins de mémoire. Il faudrait en fait regarder le contenu, ce que nous ferons plus loin. En attendant, voici donc un classement donnant la priorité aux modules standard :
- 16modules standard +:9modules propriétairesTI-Nspire CX II
- 9modules standard +:2modules propriétairesNumWorks
- 8modules standard +:34modules propriétairesTI-83 Premium CE Edition Python
- 8modules standard +:1module propriétaireHP Prime(version alpha)
- 3modules standard +:1module propriétaireCasio Graph 90+E / 35+E II
- 23modules standard +:4modules propriétairesNumWorks
- 16modules standard +:9modules propriétairesTI-Nspire CX II
- 10modules standard +:2modules propriétairesNumWorks(firmware Omega)
- 9modules standard +:2modules propriétairesNumWorks
- 8modules standard +:34modules propriétairesTI-83 Premium CE Edition Python
- 8modules standard +:1module propriétaireHP Prime(version alpha)
- 3modules standard +:1module propriétaireCasio Graph 90+E / 35+E II
- 16modules standard +:9modules propriétairesTI-Nspire CX II
- 9modules standard +:2modules propriétairesNumWorks
- 8modules standard +:47modules propriétairesTI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 8modules standard +:1module propriétaireHP Prime(version alpha)
- 8modules standard :TI-83 Premium CE + TI-Python
- 5modules standard +:1module propriétaireCasio Graph 90+E / 35+E II
- 23modules standard +:4modules propriétairesNumWorks+TI-Nspire CX
- 16modules standard +:9modules propriétairesTI-Nspire CX II
- 13modules standard :TI-83 Premium CE + TI-Python
- 10modules standard +:2modules propriétairesNumWorks(firmware Omega)
- 9modules standard +:2modules propriétairesNumWorks
- 8modules standard +:47modules propriétairesTI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 8modules standard +:1module propriétaireHP Prime(version alpha)
- 8modules standard :TI-83 Premium CE + TI-Python+Casio Graph 35/75+E(appli CasioPython)
- 7modules standard +:1module propriétaireTI-Nspire(Ndless + MicroPython)
- 5modules standard +:1module propriétaireCasio Graph 90+E / 35+E II
4) Saisie et assistant d'aide à la saisie :
Go to top


L'assistant est fonctionnel aussi bien dans l'éditeur que dans la console, dans le contexte des saisies effectuées via un menu.
Par exemple ci-contre avec l'insertion via le menu de blocs d'instructions
Les différents éléments que tu te dois de compléter dans la saisie te sont notés en gris clair, avec même une inscription indicative. C'est un peu comme un texte à trous.

Si ton curseur se trouve dans l'une des zones en question son affichage passe en inversé. Pas besoin non plus de t'acharner sur les touches fléchées pour aller rejoindre les différents bouts à compléter, tu peux passer instantanément au prochain élément à compléter à l'aide de la touche
tab!




D'ailleurs sur certaines fonctions, l'activation d'un des paramètres à compléter pourra même t'afficher des explications ou indications complémentaires sur la saisie attendue !





Dans le cas où les valeurs autorisées sont trop nombreuses, tu pourras à la place obtenir ici encore une indication fort utile sous forme d'info bulle.


Cet assistant d'aide à la saisie

5) Mémoire pile/stack :
Go to topTentons donc de déclencher une consommation massive de

- Code: Select all
def compte_r(n):
return n>0 and 1 + compte_r(n-1)
def test(f):
n = 0
try:
while 1:
n = f(n) + 1
except Exception as e:
print(e)
return n
Nous atteignons donc sur

D'où le classement des solutions
- 202:TI-Nspire CX II
- 129:NumWorks
- 82:Casio Graph 90+E / 35+E II
- 77:HP Prime(version alpha)
- 28:TI-83 Premium CE Edition Python
- 202:TI-Nspire CX II
- 129:NumWorks
- 82:Casio Graph 90+E / 35+E II
- 77:HP Prime(version alpha)
- 28:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
- 20(:45,74%contigu)TI-83 Premium CE + TI-Python
- 5362:Casio Graph 35/75+E(appli CasioPython)
- 655:Casio Graph 35+E II(appli CasioPython)
- 202:TI-Nspire CX II
- 155:TI-Nspire CX
- 130:TI-Nspire(Ndless + MicroPython)
- 129:NumWorks
- 126:NumWorks
- 82:Casio Graph 90+E / 35+E II
- 77:HP Prime(version alpha)
- 28:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
- 20:TI-83 Premium CE + TI-Python
- 15:TI-83 Premium CE + TI-Python
6) Mémoire tas/heap :
Go to topNous avons justement la chance ici de disposer du module
gc.collect()
pour nettoyer leheapen supprimant les valeurs d'objetsPythonqui ne sont plus référencéesgc.mem_alloc()
pour connaître la consommation duheapen octetsgc.mem_free()
pour connaître l'espaceheapdisponible en octets

- Code: Select all
import gc
a, f = mem_alloc(), mem_free()
(a, f, a + g)
Nous disposons donc ici d'un

Plus précisément nous avons ici
Toutefois, toutes les calculatrices
- pour un entier nul : 24octets déjà...
- pour un entier court non nul (codable sur 31 bits + 1 bit de signe):28octets
- pour un entier long :
- 28octets
- + 4octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
- pour une chaîne :
- 49octets
- + 1octet par caractère
- pour une liste :
- 64octets
- + 8octets par élément
- + les tailles de chaque élément
Nous récupérerons de plus la plus grand taille d'objet que nous avons réussi à utiliser lors de ce test, on t'explique de suite.
Voici donc le script, toujours issu du

- Code: Select all
def size(o):
t = type(o)
s = t == str and 49 + len(o)
if t == int:
s = 24
while o:
s += 4
o >>= 30
elif t == list:
s = 64 + 8*len(o)
for so in o:
s += size(so)
return s
def mem(v=1):
try:
l=[]
try:
l.append(0)
l.append(0)
l.append("")
l[2] += "x"
l.append(0)
l.append(0)
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[3], l[4] = mem(v)
except:
pass
return l[0] + l[3], max(l[0], l[4])
except:
return 0, 0
def testmem():
m1, m2 = 0, 0
while 1:
t1, t2 = mem(0)
if t1 > m1 or t2 > m2:
m1 = max(t1, m1)
m2 = max(t2, m2)
input(str((m1,m2)))
On trouve bien sur
Nous avons ici en prime une autre valeur de
D'où le classement des solutions
- 2,068 Mo(:33,36%contigu)TI-Nspire CX II
- 1,033 Mo(:38,18%contigu)Casio Graph 90+E
- 1,014 Mo(:38,91%contigu)HP Prime(version alpha)
- 101,262 Ko(:41,74%contigu)Casio Graph 35+E II
- 33,545 Ko(:40,58%contigu)NumWorks
- 18,354 Ko(:40,70%contigu)TI-83 Premium CE Edition Python
- 2,068 Mo(:33,36%contigu)TI-Nspire CX II
- 1,033 Mo(:38,18%contigu)Casio Graph 90+E
- 1,014 Mo(:38,91%contigu)HP Prime(version alpha)
- 101,262 Ko(:41,74%contigu)Casio Graph 35+E II
- 64,954 Ko(:33,69%contigu)NumWorks
- 33,545 Ko(:40,58%contigu)NumWorks
- 18,354 Ko(:40,70%contigu)TI-83 Premium CE Edition Python
- 2,068 Mo(:33,36%contigu)TI-Nspire CX II
- 1,033 Mo(:38,18%contigu)Casio Graph 90+E
- 1,014 Mo(:38,91%contigu)HP Prime(version alpha)
- 101,262 Ko(:41,74%contigu)Casio Graph 35+E II
- 33,545 Ko(:40,58%contigu)NumWorks
- 20,839 Ko(:45,74%contigu)TI-83 Premium CE + TI-Python
- 18,354 Ko(:40,70%contigu)TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
- 4,100 Mo(:38,40%contigu)TI-Nspire CX
- 2,068 Mo(:33,36%contigu)TI-Nspire CX II
- 2,050 Mo(:32,35%contigu)TI-Nspire(Ndless + MicroPython)
- 1,033 Mo(:38,18%contigu)Casio Graph 90+E
- 1,014 Mo(:38,91%contigu)HP Prime(version alpha)
- 258,766 Ko(:38,51%contigu)Casio Graph 35/75+E(appli CasioPython)
- 101,262 Ko(:41,74%contigu)Casio Graph 35+E II
- 64,954 Ko(:33,69%contigu)NumWorks
- 33,545 Ko(:40,58%contigu)NumWorks
- 32,648 Ko(:41,70%contigu)Casio Graph 35+E II(appli CasioPython)
- 23,685 Ko(:40,24%contigu)TI-83 Premium CE + TI-Python
- 20,839 Ko(:45,74%contigu)TI-83 Premium CE + TI-Python
- 18,354 Ko(:40,70%contigu)TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
En examen ou parmi les solutions officielles, la

7) Module sys - implémentation et entiers :
Go to top

dir(sys)
.sys.platform == 'TI-Nspire'
sera par exemple une astuce de test bien utile pour tes scripts en ayant besoin d'identifier la plateforme sur laquelle ils tournent.Comme on pouvait s'en douter
sys.implementation
nous confirme que nous sommes sur un sys.version
.
sys.maxsize
pour sa part indique le plus grand entier pouvant être codé nativement sur la plateforme utilisée, avec ici une organisation sys.byteorder
. sys.maxsize
détermine la taille maximale de nombre de structures telles les listes. Les variables peuvent quand même prendre des valeurs entières supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.Sur toute la concurrence nous avions jusqu'à présent
sys.maxsize == 2**31 -1
, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.Ici, on a bizarrement 2**63-1 sur le logiciel ordinateur et 32767 sur calculatrice, ce qui n'est pourtant clairement pas le maximum
8) Module ti_system - intégration, clavier et souris :
Go to top

Chez la concurrence à ce jour, l'application
- importation dans l'application Pythonde variables de type liste existant dans l'environnement de la calculatrice
- exportation depuis l'application Pythonde variables de type liste vers l'environnement de la calculatrice
Une fonctionnalité toujours exclusive à


Autre bonne nouvelle, nous avons de quoi tester la pression sur les touches clavier. Non pas une fonction

La fonction
esc | up | home | ||
scratchpad | left | center | right | doc |
tab | down | menu | ||
var | del |
= | trig | 7 | 8 | 9 | template | cat |
^ | square | 4 | 5 | 6 | * | / |
exp | 10power | 1 | 2 | 3 | + | - |
( | ) | 0 | . | − | enter |
E | A/a | B/b | C/c | D/d | E/e | F/f | G/g | ?! |
pi | H/h | I/i | J/j | K/k | L/l | M/m | N/n | |
, | O/o | P/p | Q/q | R/r | S/s | T/t | U/u | return |
V/v | W/w | X/x | Y/y | Z/z | /_ |
Enfin tu vas ici pouvoir donner une toute nouvelle dimension à tes projets d'interfaces en

9) Module de tracé par pixels ti_draw :
Go to top

Déjà à la différence de ce dernier, nous notons ici la possibilité d'utiliser du
A la différence près que pour les scripts


set_pen("épaisseur", "style")
permet de régler la plume du stylo. La fonction accepte les paramètres listés ci-contre par l'assistant de saisie, mais également des numéros selon les équivalences suivantes :- 0 = thin
- 1 = medium
- 2 = thick
- 0 = solid
- 1 = dotted
- 2 = dashed

- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1
nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
for i in range(nty):
scr.draw_text(xmin-tw, ly[i*2], str(i))
for j in range(nta):
scr.draw_text(lx[j*2], ymin+th, str(j))
scr.set_pen(j, i)
scr.draw_line(lx[j*2], ly[i*2], lx[j*2 + 1], ly[i*2])
Nous notons donc diverses fonctions de tracé de primitives :
draw_line(x1, y1, x2, y2)
: segmentdraw_rect(x, y, largeur, hauteur)
: rectanglefill_rect(x, y, largeur, hauteur)
: rectangle pleindraw_circle(x, y, rayon)
: cercledraw_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc)
: arc d'ellipsefill_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc)
: secteur d'ellipsedraw_poly(x_liste, y_liste)
: polygonefill_poly(x_liste, y_liste)
: polygone pleinplot_xy(x, y, figure)
draw_text(x, y, ...)
La fonction
La fonction

- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1
nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
for i in range(nty):
scr.draw_text(xmin-tw, ly[i*2], str(i))
for j in range(nta):
scr.draw_text(lx[j*2], ymin+th, str(j))
scr.set_pen(j, i)
scr.set_color((255,0,0))
scr.fill_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])
scr.set_color((0,0,0))
scr.draw_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])
drawRect(x, y, w, h)
permet donc de tracer un rectangle :- de dimensions wethdonnées en pixels
- aux côtés parallèles aux bords de l'écran
- et en utilisant le point de coordonnées (x, y)comme sommet supérieur gauche

- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1
nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
for i in range(nty):
scr.draw_text(xmin-tw, ly[i*2], str(i))
for j in range(nta):
scr.draw_text(lx[j*2], ymin+th, str(j))
scr.set_pen(j, i)
scr.set_color((255,0,0))
scr.fill_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
scr.set_color((0,0,0))
scr.draw_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
Voici maintenant du lourd avec
drawArc(x, y, w, h, t1, t2)
et fillArc(x, y, w, h, t1, t2)
:
- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1
nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)
for i in range(nty):
scr.draw_text(xmin-tw, ly[i*2], str(i))
for j in range(nta):
scr.draw_text(lx[j*2], ymin+th, str(j))
scr.set_pen(j, i)
scr.set_color((255,0,0))
scr.fill_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)
scr.set_color((0,0,0))
scr.draw_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)
La fonction
drawArc(x, y, dx, dy, t1, t2)
permet donc de tracer un arc d'une ellipse elle-même inscrite dans un rectangle :- de dimensions wethdonnées en pixels
- aux côtés parallèles aux bords de l'écran
- et en utilisant le point de coordonnées (x, y)comme sommet supérieur gauche
Et la fonction
draw_text(x, y, 'texte')
écrit bien évidemment du texte en prenant les coordonnées spécifiées comme coin supérieur gauche :
- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw = 10
s = 'Thank you TI'
xmin, xmax, ymin, ymax = 0, sw - 1, 0, sh - 1
x, y, dx, dy = xmin, ymin, 1, 9
while x <= xmax - tw*len(s):
scr.draw_text(x, y, s)
y += dy
x += dx
dx += 1



Tentons donc de découvrir tout cela :
- Code: Select all
import ti_draw as scr
sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1
n = 13
lx = [xmin + k*(xmax-xmin)/(2*n+1) for k in range(1, 2*n+1)]
y = ymin + (ymax-ymin)/2
l = (xmax-xmin+1) / (2*n+1)
for j in range(n):
scr.draw_text(lx[j*2], ymin+th, str(j + 1))
scr.plot_xy(lx[j*2+1], y ,j + 1)
Si l'on souhaite allumer un simple pixel, c'est donc la forme numéro 7.
Petit classement déjà en terme de zone graphique :
- 320×240=76800pixels :HP Prime(version alpha)
- 384×192=73728pixels :Casio Graph 90+E
- 320×222=71040pixels :NumWorks
- 318×212=67416pixels :TI-Nspire CX II
- 320×210=67200pixels :TI-83 Premium CE Edition Python
- 128×64=8192pixels :Casio Graph 35+E II
- 320×240=76800pixels :HP Prime(version alpha)
- 384×192=73728pixels :Casio Graph 90+E
- 320×222=71040pixels :NumWorks
- 318×212=67416pixels :TI-Nspire CX II
- 320×210=67200pixels :TI-83 Premium CE Edition Python
- 128×64=8192pixels :Casio Graph 35+E II
- 320×240=76800pixels :HP Prime(version alpha)
- 384×192=73728pixels :Casio Graph 90+E
- 320×222=71040pixels :NumWorks
- 318×212=67416pixels :TI-Nspire CX II
- 320×210=67200pixels :TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 128×64=8192pixels :Casio Graph 35+E II
- 320×240=76800pixels :TI-Nspire(Ndless + MicroPython)+HP Prime(version alpha)
- 384×192=73728pixels :Casio Graph 90+E
- 320×222=71040pixels :NumWorks+TI-Nspire CX
- 318×212=67416pixels :TI-Nspire CX II
- 320×210=67200pixels :TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 128×64=8192pixels :Casio Graph 35+E II
Mais si donc nous venons de terminer avec une fonction permettant d'allumer un pixel, nous n'avons pas vu de trace de fonction permettant de tester l'état d'un pixel.
C'est en fait que nous n'en avons pas terminé avec les modules de tracé par pixels...

10) Module de tracé par pixels ti_image :
Go to top

Comme son nom l'indique, il permet de charger et afficher des images. Il s'agit ici d'images insérées en tant que ressources dans ton classeur, il te faudra pour cela utiliser le logiciel
L'objet image
img = load_image(n)
, mais pas affiché.

img.show_image(x, y)
.Une gestion des images qui a ici le gros avantage de ne nécessiter que 2 lignes de code en


Le module
- Code: Select all
img = image.new(_R.IMG.g200)
function on.paint(gc)
gc:drawImage(img, 0, 0)
end



En réalité il s'agit d'un module qui permet en fait de travailler en pixels sur des calques hors écran, autant de calques que tu veux. Un calque se crée dans la couleur que tu souhaites d'un simple
layer = new_image(w, h, (r, g, b))
, et tu disposes ensuite de méthodes 
Très pratique ces deux dernières fonctions également pour faire du traitement d'image en SNT.

11) Module de tracé par pixels ti_picture :
Go to top
On peut l'interroger sur son contenu d'un
dir(ti_picture)
.Il semble bizarrement offrir quasiment les mêmes possibités que le module

Selon comment tu souhaites travailler sur tes calques et images
13) Bilan modules :
Go to topTentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement
- Code: Select all
from autopfrm import *
pf = get_pf()
sh_inf = shell_infos(pf)
unsafe = ()
if pf == 4: #HP Prime
unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
unsafe = ('sys.argv', 'sys.path')
if pf >= 0:
curline=0
_p = print
def print(*ls):
global curline
st=""
for s in ls:
if not(isinstance(s,str)):
s=str(s)
st=st+s
stlines=1
if sh_inf[1]:
stlines += sh_inf[2]*int(len(st)/sh_inf[1])
if curline+stlines>=sh_inf[0]:
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):
if str(obj).startswith("<module"): return False
l = ()
try: l = dir(obj)
except: pass
return len(l)
def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
global curline, found
pitm_name=sstr(pitm)
if(reset):
curline=0
found = []
pitm_name_l=[pitm_name]
pitm_str_l=[str(pitm)]
pitm_val_l=[pitm]
hd="."*(len(pitm_name_l)-1)
c = 0
l = sorted(dir(pitm))
for i in range(len(l)):
l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
try:
if not isinstanceof(pitm, str):
for i in range(len(pitm)):
l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
except: pass
for itm in l:
isFound = itm[0] in found
c += not isFound
isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
try:
if isUnsafe: raise Exception
print(hd+itm[0]+"="+str(itm[1]))
except:
print(hd+itm[0])
if not isFound:
found.append(itm[0])
if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
pitm_name_l2.append(itm[0])
pitm_val_l2.append(itm[1])
pitm_str_l2.append(itm[2])
c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
return c
def explmod(s):
global found
module = __import__(s)
found = []
return explmodr(module)
- Code: Select all
# detects calculator Python platform
def get_pf():
c256 = True
try:
if chr(256)==chr(0):
# Xcas/KhiCAS Python compatibility
if "HP" in version():
return 13 # HP Prime
else:
if not white:
return 12 # Graph 35+E II
elif "Numworks" in version():
return 10 # NumWorks
elif "Nspire" in version():
return 8 # Nspire
else: # Graph 90+E
return 11
except:
c256 = False
try:
import sys
try:
if sys.platform == "nspire":
try: # Nspire Ndless
import graphic
return 7 # KhiCAS Micropython
except: # MicroPython
return 6
elif sys.platform == "TI-Nspire":
return 3 # Nspire CX II
elif sys.platform == "numworks":
return 9 # NumWorks KhiCAS Micropython
elif sys.platform.startswith('TI-Python'):
return 2 # 83P/84+ CE
except: # Graph 35+E/USB / 75/85/95
return 5
except:
pass
if not c256:
return 1 # Graph 90/35+E II
try:
import kandinsky
return 0 # NumWorks
except:
try: # HP Prime
import hpprime
return 4
except:
pass
return -1
#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
gp, sp = lambda: None, lambda: None
if pf == 0: # NumWorks
import kandinsky
gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
elif pf == 1: # Graph 90/35+E II
import casioplot
gp, sp = casioplot.get_pixel, casioplot.set_pixel
elif pf == 2: # 83P/84+ CE
import ti_graphics
gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
elif pf == 3: # Nspire CX II
pass
elif pf == 4: # HP Prime
import hpprime
sp = hpprime.pixon
elif pf == 6: # Nspire: Ndless MicroPython
from nsp import Texture
canvas = Texture(320, 240, 0)
gp, sp = canvas.getPx, canvas.setPx
elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
import graphic
gp, sp = graphic.get_pixel, graphic.set_pixel
elif pf == 13: # HP Prime
gp, sp = gp_prime, sp_prime
return gp, sp
#returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not
def shell_infos(pf):
#NW small: [00] 12.5x30 -> 16 x 42
#HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14 x39 -> 18.5 x 45
#HP big : [03] 11.5x39 -> 09 x 35 [12] 14 x39 -> 11 x 35
# uPy uPy
# G352 CPy uPy KhiCAS---------------> CAS
# NW G90 CE CX2 HP GXX NS NS NS NW NW G90 G352HP
l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14)
l_vcols = (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39)
b_vcr = 0b1111100
if pf >= 0:
return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
else:
return max(l_vlines), max(l_vcols), 1
L'appel
explmod('nom_module')
explore le module en question et en compte les différents éléments internes, en évitant les doublons :TI- 83PCE TI- Python | TI- 83PCE Edition Python | TI- 84+CE-T Python Edition | TI- Nspire CX II | Casio Graph 90+E 35+E II | Num Works | ||||||||
builtins array (u)binascii board cmath (u)collections (u)ctypes (u)errno gc (u)hashlib (u)heapq (u)io (u)json linalg math matplotlib .pyplot micropython numpy os (u)random (u)re storage (u)struct sys time (u)timeq turtle (u)zlib TOTAL | 152 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 26 . . . 405 | 153 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 26 . . . 406 | 153 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 28 . . . 406 | 166 33 33 . 40 48 60 68 36 32 32 . . . 69 . . 41 . . 36 35 . . 80 40 . . . 849 | 141 . . . . . . . . . . . . . 47 . 58 . . . 30 . . . . . . 112 . 218- 388 | 146 . . . 34 . . . . . . . . . 63 25 22 29 . . 31 . . . . 25 . 62 . 437 | 165 32 . . 40 . . 68 36 . . . . . 69 . . 37 . . . . . . 80 . . . . 527 | 154 27 . 22 35 25 . . 30 . . . . . 64 . . 29 . 38 31 . 45 . 71 31 . . . 602 | 160 30 . . 38 . . . 33 . . . . . 67 . . 29 . . . . . . 62 . . . . 419 | 165 . 31 . 38 46 66 66 34 30 30 45 31 67 69 . 44 34 81 28 34 34 . 32 73 . . 82 32 1192 | 155 30 . . 38 . . . 33 . . . . . 67 . . 32 . . 34 . . . 55 . . . . 444 | 146 . . . 34 . . . . . . . . . 63 25 22 29 . 27 31 . . . . 25 . 62 . 472 | 168 . 34 . 41 49 69 . 37 30 33 48 34 70 72 . 47 38 46 31 37 37 . 35 77 . 34 85 35 1187 |
Passons maintenant aux modules propriétaires lorsque disponibles :
TI- 83PCE Edition Python | TI- 84+CE-T Python Edition | TI- Nspire CX II | Casio Graph 90+E 35+E II | Num Works | |||||
analogin:44 analogout:46 bbport:40 brightns:29 ce_box:32 ce_chart:58 ce_quivr:41 ce_turtl:65 color:30 colorinp:39 conservo:45 dht:45 digital:46 led:45 light:30 lightlvl:44 loudness:44 magnetic:46 mb_butns:38 mb_disp:40 mb_grove:51 mb_music:37 mb_neopx:54 mb_pins:48 mb_radio:40 mb_sensr:54 microbit:28 moisture:44 potentio:44 power:45 ranger:43 relay:45 rgb:45 rgb_arr:51 sound:29 squarewv:44 temperat:43 thermist:44 ti_graphics:67 ti_hub:42 ti_plotlib:78 ti_rover:79 ti_system:34 speaker:35 timer:35 vernier:44 vibmotor:45 | analogin:44 analogout:46 bbport:40 brightns:29 ce_box:32 ce_chart:58 ce_quivr:41 ce_turtl:65 color:30 colorinp:39 conservo:45 dht:45 digital:46 led:45 light:30 lightlvl:44 loudness:44 magnetic:46 mb_butns:38 mb_disp:40 mb_grove:51 mb_music:37 mb_neopx:54 mb_pins:48 mb_radio:40 mb_sensr:54 microbit:28 moisture:44 potentio:44 power:45 ranger:43 relay:45 rgb:45 rgb_arr:51 sound:29 squarewv:44 temperat:43 thermist:44 ti_graphics:67 ti_hub:42 ti_plotlib:78 ti_rover:79 ti_system:34 speaker:35 timer:35 vernier:44 vibmotor:45 | ti_draw:54 ti_hub:193 ti_image:53 ti_innovator:48 ti_picture:35 ti_plotlib:90 ti_rover:142 ti_st:41 ti_system:83 | casioplot | ion:72 kandinsky:28 | prime:30 | nsp:10 | arit:38 cas:28 graphic:55 nsp:37 | ion:72 kandinsky:28 | arit:41 cas:31 graphic:58 nsp:32 |
1509- 2095 | 2095 | 739 | 28 | 100 | 30 | 10 | 158 | 100 | 162 |
En comptant donc les modules non standard la

- 1915éléments +(dont:406éléments standard)TI-83 Premium CE Edition Python
- 1588éléments +(dont:849éléments standard)TI-Nspire CX II
- 557éléments +(dont:527éléments standard)HP Prime(version alpha)
- 537éléments +(dont:437éléments standard)NumWorks
- 246éléments +(dont:218éléments standard)Casio Graph 90+E / 35+E II
- 1915éléments +(dont:406éléments standard)TI-83 Premium CE Edition Python
- 1588éléments +(dont:849éléments standard)TI-Nspire CX II
- 1349éléments +(dont:1187éléments standard)NumWorks
- 578éléments +(dont:472éléments standard)NumWorks(firmware Omega)
- 557éléments +(dont:527éléments standard)HP Prime(version alpha)
- 537éléments +(dont:437éléments standard)NumWorks
- 246éléments +(dont:218éléments standard)Casio Graph 90+E / 35+E II
- 2501éléments +(dont:406éléments standard)TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 1588éléments +(dont:849éléments standard)TI-Nspire CX II
- 557éléments +(dont:527éléments standard)HP Prime(version alpha)
- 537éléments +(dont:437éléments standard)NumWorks
- 405éléments :TI-83 Premium CE + TI-Python
- 416éléments +(dont:388éléments standard)Casio Graph 90+E / 35+E II
- 2501éléments +(dont:406éléments standard)TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
- 1588éléments +(dont:849éléments standard)TI-Nspire CX II
- 1350éléments +(dont:1192éléments standard)TI-Nspire CX
- 1349éléments +(dont:1187éléments standard)NumWorks
- 602éléments :TI-83 Premium CE + TI-Python(tiers)
- 578éléments +(dont:472éléments standard)NumWorks(firmware Omega)
- 557éléments +(dont:527éléments standard)HP Prime(version alpha)
- 537éléments +(dont:437éléments standard)NumWorks
- 429éléments +(dont:419éléments standard)TI-Nspire(Ndless + MicroPython)
- 416éléments +(dont:388éléments standard)Casio Graph 90+E / 35+E II
- 405éléments :TI-83 Premium CE + TI-Python+Casio Graph 35/75+E(appli CasioPython)
14) Performances en virgule flottante :
Go to top
Commençons par les évaluer dans le contexte des calculs en virgule flottante à l'aide du script suivant, développé et utilisé pour le même si nous n'avons pas eu le temps de faire un compte-rendu public des résultats. Petit algorithme de seuil dans le contexte d'une suite récurrente, niveau Première :
- Code: Select all
try:
from time import *
except:
pass
def hastime():
try:
monotonic()
return True
except:
return False
def seuil(d):
timed,n=hastime(),0
start,u=0 or timed and monotonic(),2.
d=d**2
while (u-1)**2>=d:
u=1+1/((1-u)*(n+1))
n=n+1
return [(timed and monotonic() or 1)-start,n,u]
Pour un appel de
seuil(0.008)
, la 
La

- 0,24s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,325s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzcompatibilitéPython)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzcompatibilitéPython)
- 3,27s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 3,93s:TI-83 Premium CE Edition Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 0,24s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,325s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzcompatibilitéPython)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzcompatibilitéPython)
- 3,27s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 3,93s:TI-83 Premium CE Edition Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 6,69s:NumWorks N0110
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 33,41s:NumWorks N0110
- 0,24s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,325s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzcompatibilitéPython)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzcompatibilitéPython)
- 3,27s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 3,73s:TI-83 Premium CE+TI-Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 3,93s:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 0,24s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,27s:TI-Nspire CX(révisions A-V)
- 0,325s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzcompatibilitéPython)
- 0,38s:TI-Nspire
- 0,396s:TI-Nspire CX(révisions A-V)
- 0,47s:TI-Nspire
- 0,48s:TI-Nspire CX(révisions A-V)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,53s:TI-Nspire CX CR4+(révisions W+)
- 0,59s:Casio Graph 35/75+E
- 0,609s:TI-Nspire CX(révisions A-V)
- 0,65s:TI-Nspire CX CR4+(révisions W+)
- 0,68s:TI-Nspire CX CR4+(révisions W+)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,79s:Casio Graph 35+E II
- 0,868s:TI-Nspire CX CR4+(révisions W+)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzcompatibilitéPython)
- 1,86s:Casio Graph 35+E II
- 2,15s:Casio Graph 90+E
- 2,96s:Casio Graph 35+E II
- 3,27s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 3,65s:Casio Graph 90+E
- 3,73s:TI-83 Premium CE+TI-Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 3,9s:Casio Graph 35+E II(32 bits : SH4 @58,98- CasioPython)
- 3,93s:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 4s:Casio Graph 35/75+E(32 bits : SH4 @29,49MHz- CasioPython)
- 4,13s:TI-Nspire CX(révisions A-V)
- 4,4s:TI-83 Premium CE+TI-Python
- 5,45s:TI-Nspire CX(révisions A-V)
- 5,48s:Casio Graph 90+E(32 bits : SH4 @117,96MHz- KhiCAS)
- 6,69s:NumWorks N0110
- 7,19s:TI-Nspire CX CR4+(révisions W+)
- 7,63s:TI-Nspire CX CR4+(révisions W+)
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 13,93s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz- KhiCAS)
- 33,41s:NumWorks N0110
15) Performances en calcul entier :
Go to topPousuivons donc les tests de performances dans le contexte des nombres entiers, afin de voir si la
- Code: Select all
try:from time import monotonic
except:pass
def hastime():
try:
monotonic()
return True
except:return False
def nodivisorin(n,l):
for k in l:
if n//k*k==n:
return False
return True
def isprimep(n):
t=hastime()
s,l,k=0 or t and monotonic(),[3],7
if n==2 or n==5:return True
if int(n)!=n or n//2*2==n or n//5*5==5:
return False
if n<k:return n in l
while k*k<n:
if nodivisorin(k,l):l.append(k)
k+=2+2*((k+2)//5*5==k+2)
r=nodivisorin(n,l)
return (t and monotonic() or 1)-s,r
La
isprimep(10000019)
en 
- 0,56s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,974s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 4,39s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 4,42s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHz)
- 9s:TI-83 Premium CE Edition Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHz)
- 0,56s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,974s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 4,39s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 4,42s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHz)
- 9s:TI-83 Premium CE Edition Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHz)
- 33,41s:NumWorks N0110
- 42,75s:NumWorks N0110
- 0,56s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,974s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 4,39s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 4,42s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHz)
- 9s:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 11,26s:TI-83 Premium CE+TI-Python
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHz)
- 0,42s:TI-Nspire CX(révisions A-V)
- 0,511s:TI-Nspire CX(révisions A-V)
- 0,56s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,57s:TI-Nspire
- 0,58s:Casio Graph 35/75+E
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,59s:Casio Graph 35+E II
- 0,62s:TI-Nspire CX(révisions A-V)
- 0,63s:TI-Nspire CX CR4+(révisions W+)
- 0,67s:TI-Nspire
- 0,794s:TI-Nspire CX(révisions A-V)
- 0,86s:Casio Graph 35+E II
- 0,821s:TI-Nspire CX CR4+(révisions W+)
- 0,974s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzalpha)
- 0,99s:TI-Nspire CX CR4+(révisions W+)
- 1,08s:Casio Graph 90+E
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,18s:TI-Nspire CX CR4+(révisions W+)
- 1,58s:Casio Graph 90+E(32 bits : SH4 @117,96MHz)
- 3,02s:Casio Graph 35+E II(32 bits : SH4 @58,98- CasioPython)
- 4,39s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 4,42s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHz)
- 4,98s:Casio Graph 35/75+E(32 bits : SH4 @29,49MHz- CasioPython)
- 8,1s:TI-83 Premium CE+TI-Python(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 9s:TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition(8 + 32 bits : eZ80 @48MHz+ Cortex-M0+/ARMv6 @48MHz)
- 11,26s:TI-83 Premium CE+TI-Python
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHz)
- 19,06s:Casio Graph 35+E II
- 22,77s:Casio Graph 90+E
- 29,20s:TI-Nspire CX(révisions A-V)
- 32,76s:Casio Graph 90+E(32 bits : SH4 @117,96MHz- KhiCAS)
- 33,41s:NumWorks N0110
- 36,26s:TI-Nspire CX(révisions A-V)
- 42,75s:NumWorks N0110
- 45,34s:TI-Nspire CX CR4+(révisions W+)
- 53,24s:TI-Nspire CX CR4+(révisions W+)
- 91,71s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz- KhiCAS)
16) Conclusion :
Go to top

Cela valait vraiment le coup d'attendre le


- la meilleure implémentation Pythonofficielle pour le nombre de modules standard disponibles
- une capacité de tas / heapoffert à la hauteur des grandes capacités de la machine, le plus grandtas / heapen mode examen, ce qui te permettra d'aborder sans contrainte des projets conséquents(interfaces, jeux, ...)
- également la plus grande capacité de stack / pileen mode examen
- de loin la plus grande bibliothèque de fonctions de tracé à ce jour, que ce soit par pixels ou par coordonnées, quoi que tu veuilles tracer il y a une solution !
- cerise sur le gâteau la gestion fort bienvenue dans ce contexte du double buffering, des calques hors écran, ainsi que des images
- des images pour ceux qui le veulent affichables sans effort et quasiment sans consommation mémoire d'une simple ligne, permettant à ceux qui le souhaitent de choisir d'avancer sur les graphismes d'un projet sans se casser la tête à coder des fonctions annexes - bref plusieurs niveaux d'entrée matière à différenciation pédagogique, mettant la réalisation de chefs-d'oeuvre à la portée de chacun et œuvrant pour la réussite de tous, de grands pédagogues chez TI
- la solution Pythonla plus performante en mode examen, une fois encore à la mesure du matériel offert
C'est la bibliothèque mise en avant aux concours de recrutement des enseignants ; nous craignons que peu d'enseignants se lancent dans l'utilisation d'un
Autant sur le matériel limité de la
Il n'empêche que c'est une très belle mise à jour, le fruit doré d'un immense travail construit méticuleusement dès le départ autour des besoins des enseignants et des élèves, merci

- Mise à jour 5.2.0pour calculatrice :
- Logiciel 5.2.0pour ordinateur :