π
<-
Chat plein-écran
[^]

News 2020
August (1)
July (3)
June (2)
May (2)
April (7)
March (4)

News 2019
August (1)
June (1)
May (3)
April (7)
March (10)

News 2018
August (3)
July (7)
June (3)
May (8)
April (13)
March (5)

News 2017
August (1)
July (1)
May (10)
April (3)
March (4)

News 2016
August (12)
July (3)
June (8)
May (12)
April (7)
March (9)

News 2015
August (11)
July (7)
June (6)
May (10)
April (2)
March (6)

News 2014
October (12)
August (4)
July (3)
June (13)
May (14)
April (12)
March (15)

News 2013
October (30)
August (14)
July (8)
June (27)
May (12)
April (29)
March (19)
January (27)

News 2012
October (37)
August (40)
July (27)
June (19)
May (35)
April (34)
March (42)
January (46)

News 2011
October (22)
August (23)
July (14)
June (29)
May (44)
April (24)
March (27)

News 2010
August (6)
July (10)
June (4)
May (1)
April (2)
March (1)

News 2009
June (1)

Lance du Python sur la micro:bit avec ta TI-Nspire CX II

New postby critor » 26 Oct 2020, 16:21

12212Depuis plusieurs années,
Texas Instruments
a réalisé de gros efforts pour rendre la programmation de ses calculatrices accessible à tous. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets qu'ils imaginent sans avoir à se concentrer sur des difficultés annexes. :)

Nous pouvions déjà citer l'interface , le robot pilotable , la grille programmable ou encore l'adaptateur
TI-SensorLink
pour capteurs analogiques
Vernier
.
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté ! :bj:

Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous parlent le même langage de programmation, notamment en
SNT
, spécialité
NSI
et
Physique-Chimie
, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant ! :D

129591295812957Et pour cette rentrée 2020 grande nouvelle et révolution, tu n'as plus besoin de t'équiper en
TI-Innovator
pour bénéficier de ces formidables avantages. En effet, la
TI-83 Premium CE Edition Python
se voit rajouter la gestion du nanoordinateur programmable en
Python
dont tu étais peut-être déjà équipé·e ! :bj:

La carte
micro:bit
est initialement un projet lancé par la
BBC
(
B
ritish
B
roadcasting
C
orporation)
, le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont
ARM
,
Microsoft
et
Samsung
. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.

Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique
BBC Micro
des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs
Thomson MO5
et
TO7
inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan
IPT
(
I
nformatique
P
our
T
ous)
.

129621296112960La carte
micro:bit
dans sa version actuelle inclut :
  • un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
  • nombre de capteurs intégrés :
    • capteur de luminosité
      (lié aux diodes)
    • capteur de température
      (sur le processeur)
    • 2 boutons poussoirs
      A
      et
      B
      programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez
      Nintendo
    • accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
    • boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
  • connectivité
    Bluetooth 4.0
    basse énergie 2,4 GHz maître/esclave


12277La carte
micro:bit
utilise un connecteur
micro-USB
et ta calculatrice un
mini-USB
.

Pour relier les deux une solution est d'adjoindre un adaptateur
USB A
femelle ↔
USB mini-B OTG
mâle
au câble
micro-USB
venant avec ta carte
micro:bit
, testée avec succès.

1296512964Pour moins d'encombrement, tu as aussi la solution d'utiliser un câble direct, un
USB micro-B
mâle ↔
USB mini-A
mâle, disponible par exemple chez
StarTech
et que nous avons testé avec succès.

Mais
Texas Instruments
n'avait hélas rien publié de similaire pour les
TI-Nspire
. :'(

12970Dans un article précédent, nous t'expliquions le fonctionnement de la gestion
micro:bit
par la
TI-83 Premium CE Edition Python
.

Les menus
micro:bit
ainsi rajoutés sur la
TI-83 Premium CE Edition Python
envoient en fait du code
Python
pour exécution à la carte
micro:bit
, qui dispose de son propre interpréteur
Micropython
.
Par exemple, mb_disp.display.show("Image.PACMAN") envoie en fait le code display.show(Image.PACMAN) encadré des bons caractères de contrôle.

Après analyse du protocole de
Texas Instruments
par , nous te fournissions alors une fonction
Python
utilisant le module
ti_hub
pour te permettre d'envoyer directement ton code
Python
pour exécution à la carte
micro:bit
, t'offrant ainsi bien plus de libertés et donc possibilités que les menus de la
TI-83 Premium CE Edition Python
:
Code: Select all
from ti_hub import *

def mb_run(code):
  send('\x05') # enter paste mode (Ctrl-E)
  send(code)
  send('\x04') # exit paste mode (Ctrl-D)


Ainsi d'une fonction pour récupérer les éventuelles sorties ainsi générées sur la console de la carte
micro:bit
:
Code: Select all
def mb_get():
  return get().split("\r\n")[-3]

13179Nous avons donc aujourd'hui le plaisir de t'adapter ces deux fonctions pour
TI-Nspire CX II
. Il suffit pour cela essentiellement de remplacer l'utilisation du module
ti_hub
spécifique à la
TI-83 Premium CE Edition Python
, par celle du module
ti_innovator
spécifique à la
TI-Nspire CX II
:
Code: Select all
from ti_innovator import *

def mb_run(code):
  send('\x05') # enter paste mode (Ctrl-E)
  send(code)
  send('\x04') # exit paste mode (Ctrl-D)

def mb_get():
  return getStr().split("\r\n")[-3]

En ce jour historique, voici donc la toute première prise de contrôle d'une carte
micro:bit
par une
TI-Nspire CX II
! :bj:

Téléchargements
:


Le Python TI-Nspire CX II primé au Comenius EduMedia 2020

New postby critor » 14 Oct 2020, 11:12

Le prix
Comenius EduMedia
, du nom du philosophe, grammairien et pédagogue tchèque, est une récompense prestigieuse à rayonnement européen décernée chaque année depuis 1995 par l'allemand
GPI
(
G
esellschaft für
P
ädagogik,
I
nformation und Medien; soit société pour l'éducation, l'information et les médias)
, à des produits multimédias d'intérêt pédagogique ou didactique exceptionnel.

La remise des prix a eu lieu le
jeudi 24 septembre
à
Berlin
au cinéma-théâtre
Chamäleon
, cette année en petit comité, contexte sanitaire oblige.

Pour son édition 2020, 155 sceaux ont été attribués dans diverses catégories, dont 11 dans la catégorie enseignement mathématique et scientifique.

Texas Instruments
a l'honneur de recevoir un sceau pour sa superbe mise à jour
5.2
avec
Python
sur les
TI-Nspire CX II-T
et
TI-Nspire CX II-T CAS
! :bj:

Le constructeur peut donc désormais apposer le sceau
Comenius EduMedia Siegel 2020
sur ces produits, peut-être pour un nouvel emballage à venir d'ici la rentrée 2021.

Et puis c'est tout nous concernant. Rien pour
Casio
cette année, et rien non plus pour
NumWorks
bien que paradoxalement de plus en plus présent sur la scène européenne.

Cela fait maintenant pas moins de 6 années consécutives que
Texas Instruments
voit ainsi ses efforts pour l'innovation pédagogique récompensés par cette distinction, félicitations ! :bj:


Source
:
https://comenius-award.de/2020/08/19/co ... ward-2020/

Ndless 5, mise à jour r2016 jailbreak pour TI-Nspire CX II

New postby critor » 30 Sep 2020, 19:43

13018Le
20 septembre
dernier
sortait enfin le tant attendu
Ndless 5
, ou plus précisément la version
r2015
de
Ndless
.

Ndless
est un
jailbreak
permettant à ta
TI-Nspire
d'exécuter des programmes compilés ou assemblés en langage machine à partir de code source tiers écrit en langage
C
,
C++
ou assembleur.

Cette nouvelle édition de
Ndless
rajoutait :
  • le support des derniers modèles de la gamme
    TI-Nspire
    : :D
    • TI-Nspire CX II CAS
      ,
      TI-Nspire CX II-T CAS
      et
      TI-Nspire CX II-C CAS
    • TI-Nspire CX II-T
    • TI-Nspire CX II
  • la compatibilité avec les dernières versions du système d'exploitation : :D
  • un tout nouveau mode de compatibilité pour les programmes compilés avec le support de l'ancien écran utilisé jusqu'à la révision
    V
    des
    TI-Nspire CX
    (novembre 2015)
    , qui a le gros avantage de ne plus du tout ralentir l'exécution des programmes en question ! :bj:
Tu pouvais ainsi enfin profiter de toute la puissance du processeur
ARM9/ARMv5
de ta
TI-Nspire CX II
, avec une cadence faisant un superbe bond par rapport aux modèles précédents :
  • 132 MHz
    sur les
    TI-Nspire CX
    jusqu'à la révision matérielle
    V
    (avant novembre 2015)
  • 156 MHz
    sur les
    TI-Nspire CX
    depuis la révision matérielle
    W
    (depuis novembre 2015)
  • 396 MHz
    sur les
    TI-Nspire CX II
    ! :bj:


10892Problème toutefois, il se trouvait que
Ndless
ne fonctionnait pas bien sur les
TI-Nspire CX II
à compter de la révision matérielle
AK
. Il restait possible de l'installer, mais certains programmes redémarraient ou bloquaient la machine dès leur lancement (et il fallait donc appuyer sur le bouton reset au dos).
Problème que nous ne pouvions hélas pas détecter plus tôt puisque ne disposant jusqu'à présent pour les tests que de
TI-Nspire CX II
en révision matérielle entre
AE
et
AJ
.

Pour rappel, la révision matérielle de ta
TI-Nspire
peut être lue en clair au dos de ta machine, à la fin du code de timbre à date (
datecode
) gravé à droite du numéro de série.

Les calculatrices
TI-Nspire CX II
en révision
AK
ont commencé à être assemblées à partir de
mars 2020
environ, et commencent tout juste à être disponibles dans les stocks pour cette rentrée 2020.

Le problème a pu être identifié depuis. Il se trouve qu'à compter de la révision
AK
,
Texas Instruments
utilise un nouveau pavé tactile surnommé
capTIvate
(plus d'infos ici).

Et sachant que sur
TI-Nspire CX
les touches fléchées sont liées au pavé tactile, même sans plantage pas grand chose n'aurait de toutes façons pu marcher.

Heureusement, la toute dernière mise à jour
r2016
de
Ndless
qui sort ce soir rajoute le support du nouveau pavé tactile
capTIvate
.

Tu peux donc enfin profiter de
Ndless
et tous les programmes lui étant associés sur les
TI-Nspire CX II
récentes en révision matérielle
AK
ou
AL
:bj:

Téléchargements
:
Liens
:

Source
:
https://github.com/ndless-nspire/Ndless/issues/236

Crédits vidéos
:

Sortie Ndless 5 TI-Nspire CX II 5.2 et CX 4.5.3

New postby critor » 20 Sep 2020, 15:01

Tu l'attendais depuis très longtemps, une éternité même, 3 ans après la sortie de sa version précédente
4.5
en
septembre 2017
, et 17 mois après son blocage par
Texas Instruments
avec la mise à jour
4.5.1
d'
avril 2019
...

13018... mais ta patience va finalement être récompensée,
Ndless 5
est enfin de sortie ! :bj:

Ndless
est un
jailbreak
permettant à ta
TI-Nspire
d'exécuter des programmes compilés ou assemblés en langage machine à partir de code source écrit en langage C, C++ ou assembleur.

Cette nouvelle édition de
Ndless
t'apporte :
  • le support des derniers modèles de la gamme
    TI-Nspire
    : :D
    • TI-Nspire CX II CAS
      ,
      TI-Nspire CX II-T CAS
      et
      TI-Nspire CX II-C CAS
    • TI-Nspire CX II-T
    • TI-Nspire CX II
  • la compatibilité avec les dernières versions du système d'exploitation : :D
  • un tout nouveau mode de compatibilité pour les programmes compilés avec le support de l'ancien écran utilisé jusqu'à la révision
    V
    des
    TI-Nspire CX
    (novembre 2015)
    , qui a le gros avantage de ne plus du tout ralentir l'exécution des programmes en question ! :bj:

De quoi révéler enfin pleinement le formidable potentiel du matériel de ta
TI-Nspire CX II
! :D

Rappelons que
TI-Nspire CX
et
TI-Nspire CX II
utilisent le même processeur, un
ARM9/ARMv5
, mais pas cadencé à la même fréquence :
  • 132 MHz
    sur les
    TI-Nspire CX
    jusqu'à la révision matérielle
    V
    (avant novembre 2015)
  • 156 MHz
    sur les
    TI-Nspire CX
    depuis la révision matérielle
    W
    (depuis novembre 2015)
  • 396 MHz
    sur les
    TI-Nspire CX II
    ! :bj:

Petit aperçu des différences de performances entre les
TI-Nspire CX
et
TI-Nspire CX II
à travers plusieurs démos graphiques :




Téléchargements
:

Lien
:


Source
:
https://github.com/ndless-nspire/Ndless ... -695785341 ; viewtopic.php?f=17&t=24262&p=256051#p256051
Crédits vidéos
:
Link to topic: Sortie Ndless 5 TI-Nspire CX II 5.2 et CX 4.5.3 (Comments: 12)

Sortie/test TI-Nspire CX II 5.2 Python + QCC 2020 épilogue

New postby critor » 09 Sep 2020, 18:05

12980
Texas Instruments
nous sort enfin aujourd'hui sa tant attendue mise à jour de rentrée
TI-Nspire CX II
, la version
5.2
. :D

Il s'agit plus précisément d'une version
5.2.0.771
compilée le
15 août 2020
à
4h52
.

Cette mise à jour apporte une grande nouveauté, une application
Python
, que nous allons nous empresser de découvrir avec toi, et qui reste entièrement accessible en mode examen. :bj:


Sommaire :





1) Editeur et modèles de script :

Go to top

Sur
TI-Nspire CX II
, le
Python
n'est pas une application ayant l'honneur d'être directement disponible à l'écran d'accueil de la calculatrice. Il te faut créér un document et ensuite le
Python
sera listé en tant que 10ème type d'application rajoutable sur chaque page. L'application peut de plus être rajoutée sous deux formes différentes dont on nous propose le choix :
  • é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,
Texas Instruments
t'a conçu sur-mesure pas moins de 9 modèles de scripts prédéfinis :
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 *
#================================


Nous accédons donc à un très bel éditeur. Notons en passant que
TI
a même pensé à nous rajouter une petite icône
Python
dans l'interface en question, histoire qu'on ne la confonde avec celle de l'éditeur de programmes.

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.

Un éditeur très complet, on peut y réaliser des sélections en maintenant enfoncée la touche
shift
comme sur ordinateur, couper-copier-coller-effacer la sélection courante à l'aide des racourcis
ctrl
X
,
ctrl
C
,
ctrl
V
et
del
. La touche
menu
donnera 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
Python
qui habituellement n'indiquent qu'un numéro de ligne, la vérification syntaxique depuis l'éditeur t'amènera directement sur la ou les lignes à corriger ! :bj:




2) 1er script et console - nombres flottants et complexes :

Go to top

Bon, maintenant que nous savons utiliser l'éditeur, tentons de premiers tests simples histoire de se mettre en jambe. Etudions un petit peu le moteur de calcul numérique du
Python
en question.

Commençons par les nombres en virgule flottante dits flottants. Ce type de donnée utile pour les nombres non entiers sous la forme
$mathjax$M\times 2^{E-E_{min}}$mathjax$
, avec :
  • 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
Python
sur
TI-Nspire CX II
:
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]


Pour exécuter tout ça on peut certes recommencer comme plus haut et insérer une application
Python
cette fois-ci format console
(shell)
sur une nouvelle page, console dans laquelle il faudra donc importer manuellement notre script.

Mais on peut également utiliser la touche
menu
pour demander directement l'exécution du script depuis l'éditeur, auquel cas ce dernier sera importé automatiquement.

Notons la touche
var
qui 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
53
bits, permettant environ
16
chiffres significatifs en écriture décimale
(precm(10))
, et auxquels il faut bien évidemment rajouter 1 bit de signe.
L'appel prece() nous indique pour sa part que les valeurs codables pour les exposants dans la formule vont de
-1075
à
+1023
.
Il s'agit du standard double précison du
Python
, un excellent choix pour le contexte scientifique du lycée, et à ce jour toutes les calculatrices concurrentes disposant d'une véritable implémentation
Python
répondent la même chose.

Notons au passage avec la saisie 1j la gestion des nombres complexes dits imaginaires
(Option Maths Expertes + série STI2D)
.




3) Modules importables et modules standard :

Go to top

Tentons maintenant de réaliser ensemble une première esquisse de l'étendue de la solution
Python
TI-Nspire CX II
, avec l'éventail de modules disponibles.

Pour explorer, nous allons commencer par aller dans la console, ici encore flanquée du logo
Python
histoire qu'on ne le confonde pas avec l'application calculs.

La touche
menu
nous donne alors un accès très rapide à une sélection de différentes fonctions
Python
classées par catégories correspondant justement à des modules.

Outre le module
builtins
(intégrés)
, nous notons donc la disponibilité des modules :
  • math
  • random
    pour les fonctions aléatoires
  • ti_plotlib
    , module de tracé par coordonnées
  • ti_hub
    pour les projets d'objets connectés avec l'interface
    TI-Innovator Hub
  • ti_rover
    pour les projets de robotique avec le robot
    TI-Innovator Rover


Une sélection complémentaire de modules est également accessible via un sous-menu :
  • cmath
    pour 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


Mais nous savons par expérience que tous les modules disponibles ne sont pas forcément au menu. Tentons donc d'en demander une liste via la fonction
help()
, et plus précisément 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
Python
standard. Nous indiquerons en rouge les modules qui ne sont utilisables qu'hors examen.

La solution
Python
de la
TI-Nspire CX II
semble être excellente niveau standard avec pas moins de
16
modules, de loin la meilleure sélection officielle sur ce critère, aussi bien en examen qu'en classe ! :bj:
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
HP
Prime

α
TI-
83PCE
TI-
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+E II

Num
Works

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
HP
Prime

α
TI-
Nspire
CX


Num
Works

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 :
  1. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  2. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  3. 8
    modules standard +
    34
    modules propriétaires
    :
    TI-83 Premium CE Edition Python
  4. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  5. 3
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 23
    modules standard +
    4
    modules propriétaires
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  2. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  3. 10
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
    (firmware Omega)
  4. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  5. 8
    modules standard +
    34
    modules propriétaires
    :
    TI-83 Premium CE Edition Python
  6. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  7. 3
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  2. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  3. 8
    modules standard +
    47
    modules propriétaires
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  4. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  5. 8
    modules standard :
    TI-83 Premium CE + TI-Python
  6. 5
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 23
    modules standard +
    4
    modules propriétaires
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
    +
    TI-Nspire CX
  2. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  3. 13
    modules standard :
    TI-83 Premium CE + TI-Python
  4. 10
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
    (firmware Omega)
  5. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  6. 8
    modules standard +
    47
    modules propriétaires
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  7. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  8. 8
    modules standard :
    TI-83 Premium CE + TI-Python
    +
    Casio Graph 35/75+E
    (appli CasioPython)
  9. 7
    modules standard +
    1
    module propriétaire
    :
    TI-Nspire
  10. 5
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II




4) Saisie et assistant d'aide à la saisie :

Go to top

Exclusivité de la solution
Python
TI-Nspire CX II
à ce jour, nous y disposons d'un formidable assistant d'aide à la saisie, à un niveau jusqu'à présent jamais vu.

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
if
et
for
.

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
! :bj:

Cette formidable assistance à la saisie marche de façon similaire avec les paramètres d'appels de fonction insérés via les menus ! :bj:

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 ! :bj:


Sur d'autres paramètres ne pouvant prendre qu'un nombre fini de valeurs, l'activation de leur zone de saisie affichera automatiquement un menu contextuel à partir duquel tu pourras saisir instantanément l'une des valeurs autorisées ! :bj:

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.

Enfin, précisons que la saisie d'un point à la suite d'un objet de type prédéfini proposant des méthodes ou sous objets, pourra t'afficher automatiquement un menu contextuel avec les choix en question, et que tu bénéficieras encore dans ce contexte de toutes les fonctionnalités de l'assistant ! :bj:

Cet assistant d'aide à la saisie
TI-Nspire CX II
est véritablement exceptionnel et va te permettre d'être encore plus efficace et autonome, minimisant les besoins d'aller recourir à une quelconque documentation ! :favorite:




5) Mémoire pile/stack :

Go to top

Les interpréteurs
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. La pile
(stack)
référence, à l'exécution, les objets
Python
créés. Sa capacité limite donc le nombre d'objets
Python
pouvant coexister simultanément en mémoire.

Tentons donc de déclencher une consommation massive de
stack
, afin de pouvoir comparer et voir comment s'en sortent la
TI-Nspire CX II
et les autres. Une situation très simple qui peut être grand consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons le script suivant, issu du
QCC 2020
:
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
TI-Nspire CX II
un maximum de
202
niveaux de récursion avant erreur. C'est extraordinaire, à la fois le record de toutes les solutions officielles, et le record de toutes les solutions compatibles avec une utilisation mode examen ! :bj:

D'où le classement des solutions
Python
niveau
stack
:
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 82
    :
    Casio Graph 90+E / 35+E II
  4. 77
    :
    HP Prime
    (version alpha)
  5. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  4. 82
    :
    Casio Graph 90+E / 35+E II
  5. 77
    :
    HP Prime
    (version alpha)
  6. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 82
    :
    Casio Graph 90+E / 35+E II
  4. 77
    :
    HP Prime
    (version alpha)
  5. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  6. 20
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  1. 5362
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  2. 655
    :
    Casio Graph 35+E II
    (appli CasioPython)
  3. 202
    :
    TI-Nspire CX II
  4. 155
    :
    TI-Nspire CX
  5. 130
    :
    TI-Nspire
  6. 129
    :
    NumWorks
  7. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  8. 82
    :
    Casio Graph 90+E / 35+E II
  9. 77
    :
    HP Prime
    (version alpha)
  10. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  11. 20
    :
    TI-83 Premium CE + TI-Python
  12. 15
    :
    TI-83 Premium CE + TI-Python



6) Mémoire tas/heap :

Go to top

Les interpréteurs
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. Le tas
(heap)
stocke, à l'exécution, le contenu des objets
Python
créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.

Nous avons justement la chance ici de disposer du module
gc
, avec plusieurs fonctions bien utiles :
  • gc.collect() pour nettoyer le
    heap
    en supprimant les valeurs d'objets
    Python
    qui ne sont plus référencées
  • gc.mem_alloc() pour connaître la consommation du
    heap
    en octets
  • gc.mem_free() pour connaître l'espace
    heap
    disponible en octets
Appelons donc le petit script suivant afin d'enfin découvrir la tant attendue taille de
heap
Python
TI-Nspire CX II
:
Code: Select all
import gc
a, f = mem_alloc(), mem_free()
(a, f, a + g)

Nous disposons donc ici d'un
heap
d'une capacité impressionnante, la plus grand actuellement parmi toutes les solutions concurrentes officielles,
2,073 Mo
, de quoi a priori te lancer dans des projets
Python
très ambitieux ! :#tritop#:
Plus précisément nous avons ici
2,072 Mo
de libres, mais auxquels il faut ajouter la taille consommée par l'importation du module
gc
.

Toutefois, toutes les calculatrices
Python
ne disposent pas du module
gc
. Afin de pouvoir faire des comparaisons équitables, nous allons construire notre propre script de test d'estimation de la capacité
heap
à partir des informations suivantes sur les tailles des objets
Python
, du moins sur les plateformes 32 bits que sont à ce jour nos calculatrices :
  • pour un entier nul :
    24
    octets déjà...
  • pour un entier court non nul
    (codable sur 31 bits + 1 bit de signe)
    :
    28
    octets
  • pour un entier long :
    • 28
      octets
    • +
      4
      octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
  • pour une chaîne :
    • 49
      octets
    • +
      1
      octet par caractère
  • pour une liste :
    • 64
      octets
    • +
      8
      octets par élément
    • + les tailles de chaque élément
Nous allons donc tenter de remplir le
heap
avec plusieurs objets que nous allons faire grandir chacun son tour jusqu'à déclenchement d'une erreur, et retourner la capacité maximale que nous avons réussi à consommer.
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
QCC 2020
:
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
TI-Nspire CX II
une capacité
heap
de
2,067 Mo
proche de la mesure précédente, à laquelle bien sûr il faut rajouter la consommation du script que nous estimons à 1,056 Ko.
Nous avons ici en prime une autre valeur de
683,256 Ko
, correspondant à la taille du plus gros objet qui a pu être créé au cours du test et donc au plus grand espace libre disponible de façon contiguë dans le
heap
.

D'où le classement des solutions
Python
niveau
heap
:
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  6. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 64,954 Ko
    (
    33,69%
    contigu)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  6. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  7. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  6. 20,839 Ko
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  7. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  1. 4,100 Mo
    (
    38,40%
    contigu)
    :
    TI-Nspire CX
  2. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  3. 2,050 Mo
    (
    32,35%
    contigu)
    :
    TI-Nspire
  4. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  5. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  6. 258,766 Ko
    (
    38,51%
    contigu)
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  7. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  8. 64,954 Ko
    (
    33,69%
    contigu)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  9. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  10. 32,648 Ko
    (
    41,70%
    contigu)
    :
    Casio Graph 35+E II
    (appli CasioPython)
  11. 23,685 Ko
    (
    40,24%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  12. 20,839 Ko
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  13. 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
TI-Nspire CX II
est la meilleure niveau
heap
! :bj:




7) Module sys - implémentation et entiers :

Go to top

Un module très intéressant à explorer pour découvrir des choses, c'est le module standard
sys
. Il n'est certes pas au menu, mais on peut quand même obtenir la liste des différents éléments qu'il permet d'appeler via un simple 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
Micropython
, en précisant qu'il s'agit d'une version
1.11.0
, et implémentant lui-même le
Python 3.4.0
comme l'indique 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
little endian
comme l'indique 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

Tentons maintenant d'en apprendre davantage sur la valeur ajoutée apportée par
Texas Instruments
à la solution
Python
de la
TI-Nspire CX II
. Nous allons pour cela explorer les modules propriétaires ; commençons par regarder du côté du module système de
Texas Instruments
, le
ti_system
, et nous évoquerons le module du même nom sur
TI-83 Premium CE Edition Python
.

Chez la concurrence à ce jour, l'application
Python
a le défaut de tourner en vase clos dans son coin. Elle ne permet pas de partager des données avec le reste des applications de la calculatrice, et ne s'intègre donc pas naturellement dans la démarche de résolution d'un problème.

Texas Instruments
avait déjà proposé un début d'intégration du
Python
à l'environnement mathématique de la calculatrice avec le module de la
TI-83 Premium CE Edition Python
. Au menu la possibilité de faire rentrer et sortir des données de l'application
Python
:
  • importation dans l'application
    Python
    de variables de type liste existant dans l'environnement de la calculatrice
  • exportation depuis l'application
    Python
    de variables de type liste vers l'environnement de la calculatrice
Listes de nombres réels uniquement, les nombres complexes étant exclus. Les mêmes données devenaient ainsi traitables sous différentes applications pour une bien meilleure recherche et résolution de problème, faisant intervenir diverses représentations et compétences.

Une fonctionnalité toujours exclusive à
Texas Instruments
à ce jour et que nous avons le grand plaisir de retrouver ici avec les fonctions
store_list()
et
recall_list()
. :bj:

Texas Instruments
en profite même pour étendre la chose.
store_value()
et
recall_value()
te permettront la même chose mais cette fois-ci avec des variables numériques
(réelles)
.

Texas Instruments
va même beaucoup plus loin que ça avec
eval_function()
. Cette fonction permet à tes scripts
Python
de faire appel à une fonction définie dans ton classeur courant, fonctions à une variable uniquement mais c'est déjà un très bon début ! :bj:

Autre bonne nouvelle, nous avons de quoi tester la pression sur les touches clavier. Non pas une fonction
wait_key()
blocante ne permettant pas de coder autre chose que des menus et jeux tour par tour comme sur
TI-83 Premium CE
, mais un véritable
get_key()
non blocant qui te donnera une totale liberté pour tes projets d'interfaces et jeux ! :bj:
La fonction
get_key()
renvoie une chaîne de caractères, identifiant la touche ou combinaison de touches pressée, et en voici une petite carte afin de t'y retrouver :
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
Python
, car tu disposes même d'une fonction
get_mouse()
pour tester la position du pointeur souris ! :bj:




9) Module de tracé par pixels ti_draw :

Go to top

ti_draw
est donc le module de tracé par pixels de la
TI-Nspire CX II
. Avec un nom différant du
ti_graphics
de la
TI-83 Premium CE Edition Python
nous ne nous attendons certes pas à de la compatibilité, mais également pas au même fonctionnement.

Déjà à la différence de ce dernier, nous notons ici la possibilité d'utiliser du
double-buffering
.

get_screen_dim()
nous apprend que la zone graphique que l'on contrôle fait
318×212
pixels, comme pour les scripts
Lua
supportés depuis la version
3.0
.
A la différence près que pour les scripts
Lua
la zone graphique était liée aux dimensions de l'application concernée. Ici cela semble être indépendant. L'affichage graphique ne semble pas être redimensionnable et se fait toujours sur une fenêtre
popup
plein écran offrant donc
318×212
pixels.

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

Nous allons t'illustrer de suite ce que les différentes combinaisons de réglages signifient :
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) : segment
  • draw_rect(x, y, largeur, hauteur) : rectangle
  • fill_rect(x, y, largeur, hauteur) : rectangle plein
  • draw_circle(x, y, rayon) : cercle
  • draw_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : arc d'ellipse
  • fill_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : secteur d'ellipse
  • draw_poly(x_liste, y_liste) : polygone
  • fill_poly(x_liste, y_liste) : polygone plein
  • plot_xy(x, y, figure)
  • draw_text(x, y, ...)

La fonction
draw_poly()
permet donc de tracer une ligne brisée.
La fonction
fill_poly()
permet quant à elle de colorier le polygone obtenu en fermant cette ligne brisée.
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
    w
    et
    h
    donné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
La fonction
fillRect()
quant à elle permet de colorier le rectangle en question.
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
    w
    et
    h
    donné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
t1
et
t2
sont les angles au centre orientés délimitant l'arc en question, exprimés en degrés.

Et la fonction
fillArc()
permet quant à elle de colorier le secteur d'ellipse obtenu par balayage de l'arc en question.

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


Enfin,
plot_xy(x, y, style)
te permet d'allumer un point, et selon pas moins de 13 formes prédéfinies selon l'assistant de saisie ! :o

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 :
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    TI-Nspire
    +
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
    +
    TI-Nspire CX
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  6. 128×64
    =
    8192
    pixels :
    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

ti_image
est donc un module de tracé par pixels complémentaire du précédent, avec a priori pas beaucoup de fonctions.

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
TI-Nspire
et l'éditeur de script
Lua
.

L'objet image
Python
correspondant est ensuite créé d'un simple img = load_image(n), mais pas affiché.

En fait c'est l'objet image ainsi créé qui apporte les fonctions utiles, dont ici le 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
Python
, de ne pas inclure les données des images dans ton script
Python
, et donc d'économiser grandement la consommation du
heap
! :bj:

Par contre, il n'y aurait pas comme un petit
bug
, non ?

Le module
ti_image
semble afficher les ressources images du classeur à l'envers... alors que l'image en question avait un aperçu correct dans l'éditeur montré précédemment, et que la même ressource est visiblement affichée correctement ci-contre par un script
Lua
.
Code: Select all
img = image.new(_R.IMG.g200)

function on.paint(gc)
  gc:drawImage(img, 0, 0)
end


Mais
ti_image
est très loin de ne servir qu'aux images... ;)

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
set_pixel()
et enfin
get_pixel()
pour faire tout ce que tu veux avec ! :bj:

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

ti_picture
est donc quant à lui un module de tracé par pixels secret, puisque n'étant pas au menu.

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
ti_image
précédent...

A une petite différence près, c'est qu'ici les données des calques sont stockés sous le type standard
bytearray
au format
RGB
24 bits.

Selon comment tu souhaites travailler sur tes calques et images
(par pixels ou par octets)
, ainsi que le degré de compatibilité que tu souhaites te laisser avec d'autres plateformes,
ti_picture
pourra donc parfois être un meilleur choix que
ti_image
.




13) Bilan modules :

Go to top

Plus haut nous avions donc évalué la richesse de la plateforme en nous basant sur le nombre de modules standard disponibles. Nous avions exclu les modules propriétaires du classement, car cela n'avait pas de sens : un gros module propriétaire sur
TI-Nspire CX II
se voit découpé en plein de petits modules propriétaires sur
TI-83 Premium CE Edition Python
.

Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement
QCC 2020
. Et comme nous n'avions justement pas traité ce point publiquement dans ce contexte, c'est maintenant l'occasion :
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
HP
Prime

α
TI-
83PCE
TI-
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+E II

Num
Works

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
HP
Prime

α
TI-
Nspire
CX


Num
Works

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
TI-Nspire CX II
reste parmi les meilleures solutions
Python
et c'est toujours
Texas Instruments
qui majore la promotion : :bj:

  1. 1915
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  4. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  5. 246
    éléments +
    (dont
    218
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 1915
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 1349
    éléments +
    (dont
    1187
    éléments standard)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  4. 578
    éléments +
    (dont
    472
    éléments standard)
    :
    NumWorks
    (firmware Omega)
  5. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  6. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  7. 246
    éléments +
    (dont
    218
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 2501
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  4. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  5. 405
    éléments :
    TI-83 Premium CE + TI-Python
  6. 416
    éléments +
    (dont
    388
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 2501
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 1350
    éléments +
    (dont
    1192
    éléments standard)
    :
    TI-Nspire CX
  4. 1349
    éléments +
    (dont
    1187
    éléments standard)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  5. 602
    éléments :
    TI-83 Premium CE + TI-Python
  6. 578
    éléments +
    (dont
    472
    éléments standard)
    :
    NumWorks
    (firmware Omega)
  7. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  8. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  9. 429
    éléments +
    (dont
    419
    éléments standard)
    :
    TI-Nspire
  10. 416
    éléments +
    (dont
    388
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  11. 405
    éléments :
    TI-83 Premium CE + TI-Python
    +
    Casio Graph 35/75+E
    (appli CasioPython)




14) Performances en virgule flottante :

Go to top

Autre point très attendu, les performances du
Python
TI-Nspire CX II
. ;)

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
TI-Nspire CX II
te répond au quart de tour en seulement
0,24s
! :bj:

La
TI-Nspire CX II
est vraiment extraordinaire en calcul flottant
Python
écrasant toute concurrence de sa toute puissance, même en comptant les solutions
Python
tierces, et même en dopant la concurrence avec un
overclocking
au max ! :#tritop#:
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  10. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  11. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,27s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + MicroPython)
  3. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  5. 0,38s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 overclocké @120MHz @
    150MHz
    Nover - + MicroPython)
  6. 0,396s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX
    Micropython
    )
  7. 0,47s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - + MicroPython)
  8. 0,48s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + MicroPython)
  9. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  10. 0,53s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + MicroPython)
  11. 0,59s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @29,49MHz overclocké @
    267,78MHz
    Ftune2 - CasioPython)
  12. 0,609s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX
    Micropython
    )
  13. 0,65s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX
    Micropython
    )
  14. 0,68s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + MicroPython)
  15. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  16. 0,79s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - CasioPython)
  17. 0,868s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX
    Micropython
    )
  18. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  19. 1,86s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3)
  20. 2,15s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3)
  21. 2,96s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - KhiCAS)
  22. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  23. 3,65s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3 - KhiCAS)
  24. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  25. 3,9s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98
    - CasioPython)
  26. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  27. 4s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  28. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  29. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  30. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX compatibilité
    Python
    )
  31. 5,48s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  32. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  33. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  34. 7,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX compatibilité
    Python
    )
  35. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  36. 13,93s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  37. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )




15) Performances en calcul entier :

Go to top

Mais contrairement aux langages historiques de nos calculatrices, le
Python
distingue les nombres entiers des nombres flottants.

Pousuivons donc les tests de performances dans le contexte des nombres entiers, afin de voir si la
TI-Nspire CX II
s'en sort toujours aussi bien. Voici donc un script réalisant un test de primalité :
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
TI-Nspire CX II
répond ici à l'appel isprimep(10000019) en
0,56s
! :bj:


  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  10. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  11. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  10. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  1. 0,42s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + MicroPython)
  2. 0,511s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX
    Micropython
    )
  3. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,57s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 overclocké @120MHz @
    150MHz
    Nover - + MicroPython)
  5. 0,58s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @29,49MHz overclocké @
    267,78MHz
    Ftune2 - CasioPython)
  6. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  7. 0,59s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - CasioPython)
  8. 0,62s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + MicroPython)
  9. 0,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + MicroPython)
  10. 0,67s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - + MicroPython)
  11. 0,794s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX
    Micropython
    )
  12. 0,86s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3)
  13. 0,821s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX
    Micropython
    )
  14. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  15. 0,99s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + MicroPython)
  16. 1,08s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3)
  17. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  18. 1,18s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX
    Micropython
    )
  19. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  20. 3,02s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98
    - CasioPython)
  21. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  22. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  23. 4,98s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  24. 8,1s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  25. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  26. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  27. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  28. 19,06s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - KhiCAS)
  29. 22,77s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3 - KhiCAS)
  30. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  31. 32,76s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  32. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  33. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX compatibilité
    Python
    )
  34. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  35. 45,34s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  36. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX compatibilité
    Python
    )
  37. 91,71s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)




16) Conclusion :

Go to top

Last but not least...
Texas Instruments
ne publie habituellement qu'1 à 2 mises à jour par an, mais alors quelle mise à jour cette fois-ci ! :#roll#:
"Gute Dinge brauchen Zeit..."
comme dit le proverbe allemand,
"... and better things even longer"
complète-t-on sans doute à Dallas. ;)

Cela valait vraiment le coup d'attendre le
Python
TI-Nspire CX II
, une solution supérieure sur nombre de points à tout ce qui a pu se faire sur calculatrices concurrentes jusqu'à présent ! :bj:

Texas Instruments
semble avoir fait appel à des experts en
Python
et en pédagogie, l'assistant d'aide à la saisie, à ce jour une exclusivité à un tel niveau, est un fidèle compagnon qui devrait permettre de commencer à coder très rapidement et en grande autonomie, ravissant petits et grands, lycéens comme enseignants ! :favorite:

Texas Instruments
semble également avoir été présent sur tous les fronts, on retient :
  • la meilleure implémentation
    Python
    officielle pour le nombre de modules standard disponibles :bj:
  • une capacité de
    tas / heap
    offert à la hauteur des grandes capacités de la machine, le plus grand
    tas / heap
    en mode examen, ce qui te permettra d'aborder sans contrainte des projets conséquents
    (interfaces, jeux, ...)
    :bj:
  • également la plus grande capacité de
    stack / pile
    en mode examen :bj:
  • 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 ! :bj:
  • 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
    Python
    la plus performante en mode examen, une fois encore à la mesure du matériel offert :bj:
Tout petit bémol, en espérant être entendu, nous regrettons par contre le non respect d'un standard comme
matplotlib.pyplot
pour le module de tracé dans un repère.
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
ti_plotlib
propriétaire qui sera incompatible avec les scripts des livres ainsi qu'avec la solution
Python
tournant en classe sur la tablette ou l'ordi, nuisant ainsi à l'interopérabilité.
Autant sur le matériel limité de la
TI-83 Premium CE Edition Python
on pouvait comprendre ce choix, autant ici ce n'est pas le cas.

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
TI
! :favorite:




Téléchargements
:


Mise à jour TI-Nspire CX 4.5.3 de rentrée 2020

New postby critor » 03 Sep 2020, 11:08

Grosse surprise aujourd'hui,
Texas Instruments
nous offre une mise à jour de rentrée inespérée pour ses calculatrices
TI-Nspire CX
de première génération
(hors
TI-Nspire CX II
donc)
.

Le système
TI-Nspire CX
passe donc de la version
4.5.2
à la version
4.5.3
, plus précisément
4.5.3.14
compilée le
30 avril 2020
à
11h35min52s
.

Nous ignorons à ce jour tout des nouveautés, en tous cas après exploration rapide pas de
Python
contrairement à la mise à jour à venir d'ici quelques jours pour
TI-Nspire CX II
.

Attention, cette mise à jour une fois effectuée interdira tout retour à une version inférieure à
4.5.3.14
.
Si ta calculatrice dispose actuellement d'une version
4.5.0
ou inférieure, en installant une version
4.5.1
ou supérieure
de façon normale
tu renonces à ce jour définitivement à
Ndless
. /!

De plus, le chargeur de démarrage tiers
ControlX
pour
nBoot
n'est pour le moment pas à jour avec la gestion de la version
4.5.3
.
Pour le chargeur de démarrage tiers
nLoader
c'est bien pire, il n'est même pas à jour avec la gestion des versions
4.5.1
et supérieures.
N'effectue pas la mise à jour si tu fais tourner un de ces chargeurs sur ta machine. :#non#:



Tutoriels
:



Téléchargements
:


Vidéoconférence découverte Python TI-Nspire CX II 4 août 18h

New postby critor » 04 Aug 2020, 16:55

Pour cette rentrée 2020,
Texas Instruments
rajoute la programmation
Python
à ses calculatrices
TI-Nspire CX II
via une mise à jour gratuite.

Envie de découvrir tout cela en avant-première ?

Rendez-vous donc à la vidéoformation ce
mardi 4 août
18h-19h
, en allemand.

Tu pourras comme à l'habitude poser toutes les questions de ton choix, mais dans la langue de
Goethe
cette fois-ci. ;)

Inscription
:
https://tiedtech.webex.com/mw3300/myweb ... &service=6

Doki Doki Literature Club, adapté en Lua pour TI-Nspire !

New postby critor » 26 Jul 2020, 15:37

Doki Doki Literature Club!
est un jeu vidéo de type
visual novel
, un genre très populaire en Asie, sorti en 2017 pour
Windows
,
Mac
et
Linux
. Tu contrôle le personnage jouable qui rejoint le club de littérature du lycée, déjà constitué de
Natsuki
,
Yuri
et
Monika
.

Mais non, même si la première de ses quatre parties du jeu peut te le laisser croire en en adoptant tous les codes, contrairement à nombre de jeux adoptant ce format ce n'est pas un jeu de séduction.
Retournement de situation à la fin de la première partie, il ne s'agit pas ici de choisir entre les 3 filles. Au contraire le jeu brisera régulièrement le quatrième mur; certaine(s) d'entre elles ayant pleinement conscience d'être des personnages d'un jeu vidéo et finiront par s'adresser directement à toi, t'invitant à effectuer quelques manipulations dans les fichiers du jeu, fichiers qui contiennent entre autres les personnalités de chacune.

12696Aujourd'hui grâce à et
MrZ
,
Doki Doki Literature Club
est enfin disponible pour
TI-Nspire
dans une version simplifiée :
Doki Doki Literature Club: Just Monika!
:D

Plus précisément il s'agit d'une adaptation de la seule troisième et avant-dernière partie du jeu, où tu restes seul avec
Monika
après que celle-ci ait effacé les fichiers définissant
Yuri
et
Natsuki
.

Le jeu est ici codé en
Lua
et donc officiellement utilisable sur toute
TI-Nspire
mise à jour en version
3.0
ou supérieure. :)

Pas de possibilité ici pour un script
Lua
de lire/écrire d'autres fichiers que le sien, mais la chose est habilement contournée en t'invitant à installer le fichier de
Monika
dans le dossier
MyLib
, dossier prévu pour les bibliothèques, c'est-à-dire les classeurs souhaitant rendre disponible tout ou partie de leurs fonctions de façon globale. Un très bel effort d'adaptation et de respect de l'esprit du jeu original ! :bj:

Monika
fera à plusieurs reprises référence à ta calculatrice et à son dossier
MyLib
. Attention donc à ce que tu fais avec, car ici le jeu continue hors du jeu... :#non#:



Téléchargement
:
archives_voir.php?id=2638297

-
Search
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.2 pour les Nspire CX II
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
532 utilisateurs:
>523 invités
>3 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)