π
<-
Chat plein-écran
[^]

Divers QCC 2020 épisode 7 : définitions écrans et zones graphiques

New postby critor » 19 Aug 2020, 10:49

5409
Quelle Calculatrice programmable Choisir 2020


Episode 7 - Définitions écrans et zones graphiques




Plus tôt cette année nous avons donc traité des tailles des écrans des calculatrices graphiques affichant une conformité pour les examens 2021, l'un des éléments matériels les plus importants. Mais la taille ne fait pas tout, reste à voir la définition en pixels ainsi que nombre d'autres caractéristiques que nous allons méticuleusement tester en
Python
comme jamais auparavant. Prépare-toi à découvrir nombre de secrets... ;)



Nous allons donc te donner ici entre autres les caractéristiques et définitions des écrans.

Mais la définition elle non plus ne fait pas tout, car il faut également voir quelle est la zone graphique par rapport à ça, c'est-à-dire la zone dans laquelle l'utilisateur peut librement allumer des pixels.
L'accès en écriture à cette zone graphique se fait notamment via le grapheur de fonctions, ainsi que via des scripts ou programmes.
Sur nombre de modèles dont le système a été développé avant l'ère du
Python
, le langage de programmation historique utilise la même zone graphique que le grapheur de fonctions. Par contre, l'application
Python
sortie depuis pour nombre de ces modèles ne reprend pas toujours exactement la même zone graphique...

Nous effectuerons donc jusqu'à 2 tests par modèle :
  • un test de la zone graphique en utilisant soit le grapheur de fonctions soit un programme en langage historique
  • un test de la zone graphique en
    Python

Commençons dès maintenant à construire et expliquer devant toi notre protocole de test
Python
, avec un script universel tournant sur tous les modèles supportant officiellement ou officieusement ce langage. Nous adapterons si besoin dans d'autres langages pour les modèles ne comprenant pas encore le langage
Python
.

Les fonctions de lecture/écriture des pixels différant hélas d'un constructeur à un autre, il nous faut déjà de quoi permettre au script de détecter la plateforme sur laquelle il tourne :
Code: Select all
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      if "HP" in version():
        return 12
      else:
        if not white:
          return 11
        elif "Numworks" in version():
          return 9
        elif "Nspire" in version():
          return 7
        else:
          return 10
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try:
          import graphic
          return 6
        except:
          return 5
      elif sys.platform == "numworks":
        return 8
      elif sys.platform.startswith('TI-Python'):
        return 2
    except:
      return 4
  except:
    pass
  if not c256:
    return 1
  try:
    import kandinsky
    return 0
  except:
    try:
      import hpprime
      return 3
    except:
      pass
  return -1

Cette pièce d'horlogerie te retournera d'un simple get_pf() un identifiant couvrant tout l'éventail des solutions
Python
disponibles à ce jour pour calculatrices, et à interpréter de la façon suivante : :bj:
  • -1:
    inconnue
    (ordinateur ?...)
  • 0:
    NumWorks
  • 1:
    Casio Graph 90+E
    ou
    Graph 35+E II
  • 2:
    TI-83 Premium CE
    ou
    TI-84 Plus CE
  • 3:
    HP Prime
    (version alpha)
  • 4:
    Casio Graph 35+E/USB
    ou
    Graph 75/85/95
    avec
  • 5:
    TI-Nspire
    +
    (nécessite
    Ndless
    )
  • 6:
    TI-Nspire
    + en mode
    MicroPython
    (nécessite
    Ndless
    )
  • 7:
    TI-Nspire
    + en mode de compatibilité
    Python
    (nécessite
    Ndless
    )
  • 8:
    NumWorks
    + en mode
    MicroPython
    (nécessite
    Omega
    )
  • 9:
    NumWorks
    + en mode de compatibilité
    Python
    (nécessite
    Omega
    )
  • 10:
    Casio Graph 90+E
    + en mode de compatibilité
    Python
  • 11:
    Casio Graph 35+E II
    + en mode de compatibilité
    Python
  • 12:
    HP Prime
    en mode
    CAS

Maintenant que nous connaissons donc la plateforme, reste à récupérer les fonctions d'accès aux pixels :
Code: Select all
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:
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1:
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2:
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3:
    import hpprime
    sp = hpprime.pixon
  elif pf == 5:
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 6 or pf == 8:
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 12:
    gp, sp = gp_prime, sp_prime
  return gp, sp

Voilà, d'un simple gp, sp = get_pixel_functions(get_pf()) nous obtenons les fonctions de lecture et écriture des pixels, sur tous les modèles où elles existent ! :bj:

Comment donc faire maintenant pour tester la taille de la zone graphique, rien qu'en lisant / écrivant des pixels ?
Et bien c'est très simple, tu ne vas pas être dépaysé(e). ;)
Nous allons procéder comme avec une tortue
(langage
Scratch
ou module
Python turtle
)
.
Nous allons parcourir l'écran, en diagonale, en tentant de lire et modifier chaque pixel rencontré.

Pour savoir si un pixel est accessible en écriture, nous tenterons d'inverser sa couleur :
Code: Select all
def invert_color(c):
  try:
    ci = [0, 0, 0]
    for k in range(3):
      ci[k] = 255 - c[k]
  except:
    ci = ~(c&0xffffff) & 0xffffff
  return ci

def is_pixel_writable(x, y, bad_pixel):
  if is_pixel_readable(x, y, bad_pixel):
    c0 = gp(x, y)
    sp(x, y, invert_color(c0))
    c = gp(x, y)
    return c != c0


Pour savoir si un pixel que l'on arrive à lire correspond bien à un pixel visible de l'écran, nous prendrons comme référence la mauvaise valeur de pixel retournée par une lecture clairement hors écran, coordonnées (-2, -2).
Dans le seul cas où l'on rencontre cette valeur qui peut très bien être justifiée, nous tenterons ici encore de l'inverser.
Code: Select all
def is_pixel_readable(x, y, bad_pixel):
  c = None
  try:
    c = gp(x, y)
  except:
    pass
  if c != None:
    if c == bad_pixel:
      sp(x, y, invert_color(c))
      c = gp(x, y)
  return c != bad_pixel


Voici donc les fonctions principales utilisant tout ça :
Code: Select all
def scr_test(x0, y0, dx0, dy0, test):
  bad_pixel = None
  try:
    bad_pixel = gp(-2, -2)
  except:
    pass
  x, y, dx, dy = x0, y0, dx0, dy0
  while not test(x, y, bad_pixel):
    x += dx
    y += dy
  if test(x, y - dy, bad_pixel): y = y0
  elif test(x - dx, y, bad_pixel): x = x0
  x0, y0 = x, y
  x += dx
  y += dy
  while(dx or dy):
    if not test(x - ((dx == 0) and dx0),y - ((dy == 0) and dy0), bad_pixel):
      if test(x - ((dx == 0) and dx0), y - ((dy == 0) and dy0) - dy0, bad_pixel): dy = 0
      elif test(x - ((dx == 0) and dx0) - dx0, y - ((dy == 0) and dy0), bad_pixel): dx = 0
      else: dx, dy = 0, 0
    x += dx
    y += dy
  return x0, y0, (x - x0) // dx0, (y - y0) // dy0

def scr_size():
  xrd0, yrd0, xrd, yrd = scr_test(0, 0, -1, -1, is_pixel_readable)
  xra0, yra0, xra, yra = scr_test(1, 1, 1, 1, is_pixel_readable)
  xr0, yr0 = xrd0 - xrd + 1, yrd0 - yrd + 1
  xr, yr = xra + xrd, yra + yrd
  xw0, yw0, xw, yw = scr_test(xr0, yr0, 1, 1, is_pixel_writable)
  print("at (" + str(xr0) + "," + str(yr0) + "): " + str(xr) + "x" + str(yr) + " readable pixels")
  print("at (" + str(xw0) + "," + str(yw0) + "): " + str(xw) + "x" + str(yw) + " writable pixels")
  return xr0, yr0, xr, yr, xw0, yw0, xw, yw


Il suffit donc d'appeler scr_size(), et tu vas vite comprendre avec notre premier exemple. :)

Prenons donc pour commencer les
TI-83 Premium CE
et
TI-84 Plus CE
, disposant d'un écran couleur
320×240= 76800
pixels.

On peut obtenir la taille de la zone graphique accessible au grapheur ainsi qu'aux programmes grâce à un tout petit calcul effectué par le programme ci-dessous à partir des bornes de la fenêtre graphique :
Code: Select all
(Xmax-Xmin)/ΔX+1→W
(Ymax-Ymin)/ΔY+1→H
{W,H

Nous bénéficions donc pour nos graphiques et programmes d'une zone de
265×165= 43725
pixels, une zone extrêmement décevante ne permettant d'exploiter que
56,93%
de la définition de l'écran. :mj:
Ce n'est pas pour rien que les plus grands créateurs de jeux programmaient en langage machine dit assembleur...


Passons maintenant dans l'application
Python
, qui n'offre les fonctions de pixels que sur
TI-83 Premium CE Edition Python
et
TI-84 Plus CE-T Python Edition
.
Texas Instruments
y a enfin corrigé ce gros défaut. Après donc parcours de l'écran en diagonale par notre tortue virtuelle, cette dernière nous reporte :
  • 321×241= 77361
    pixels pouvant être lus à partir des coordonnées (-1, -1)
  • 321×210= 67410
    pixels pouvant être écrits à partir des coordonnées (-1, 30)

Si le fonctionnement est simple, plusieurs bizarreries dans le résultat sont toutefois à traiter ici.

Déjà sur les deux zones différentes qui nous sont retournées :
  • la première signifie que l'on peut lire l'intégralité des pixels de l'écran
  • la deuxième ne retient donc plus que les pixels pouvant être modifiés, ici situés en-dessous de la barre d'état de 30 pixels de hauteur, et c'est celle-ci qui correspond à la zone graphique, la seule zone où la tortue a réussi à tracer son chemin comme tu vois ci-contre

Ensuite, selon notre tortue nous aurions donc un écran de
321×241
pixels, soit plus que les
320×240
pixels précédemment annoncés, avec :
  • une ligne de pixels d'ordonnée -1 pouvant être lus
  • une colonne de pixels d'abscisse -1 pouvant être lus, et également écrits à partir de l'ordonnée 30 marque le début de la zone graphique précédente

Or une tentative d'écriture donc sur cette dernière colonne ne donne visiblement rien à l'écran.

Soit il y a un bug dans notre code expliquant ce résultat différent de la réalité, et tu verras bien ci-dessous si la même anomalie est présente sur d'autres modèles ou pas avec exactement le même code.

Soit la chose vient de
Texas Instruments
. Nous aurions donc un écran de
320×240
pixels, mais avec en mémoire un
buffer
associé de
321×241
pixels. Ou bien c'est un bug, ou bien il y a une raison technique que nous ignorons à ce jour pour disposer en mémoire d'1 ligne et d'1 colonne supplémentaires de pixels sans aucune existence physique.

Pour notre classement, nous retiendrons donc ici une zone graphique correspondant à la réalité, c'est-à-dire de
320×210= 67200
pixels, soit
87,50%
de la définition de l'écran, c'est déjà bien mieux qu'avec le langage historique ! :bj:

Passons aux
TI-82 Advanced
et
TI-84 Plus T
, qui t'offrent un écran monochrome de
96×64= 6144
pixels, un écran utilisant de plus des cristaux liquides noirs fort bien contrastés.

Voici le même programme pour calculer la taille de la zone graphique accessible au grapheur ainsi qu'aux programmes :
Code: Select all
(Xmax-Xmin)/PasX+1→W
(Ymax-Ymin)/PasY+1→H
{W,H

Nous contrôlons donc
95×63= 5985
pixels, soit
97,41%
de l'écran.

Voici maintenant venir la
Casio Graph 90+E
, avec son superbe écran couleur de
396×224= 88704
pixels.

Pour la zone graphique historique, petit problème de détection, nous n'avons pas de variable nous donnant le pas vertical
(écart entre 2 pixels sur l'axe des ordonnées)
. Toutefois il nous suffit de choisir la fenêtre graphique par défaut qui a l'avantage de donner un repère orthonormal, et ensuite il suffit donc de calculer avec le pas horizontal :
Code: Select all
(Xmax-Xmin)÷Xdot+1→W
(Ymax-Ymin)÷Xdot+1→H
{W,H

Via les graphes et les programmes, nous avons donc accès à une zone de
379×187= 70873
soit
79,90%
des pixels de l'écran.

Mais voyons maintenant ce que cela donne dans l'application
Python
.

Et c'est extraordinaire,
Casio
ici aussi a fait un effort, ce sont pas moins de
384×192= 73728
pixels qui sont contrôlables en
Python
, soit
83,12%
de l'écran ! :bj:

Notons que tu as également la possibilité d'installer l'application , une adaptation pour ta calculatrice du logiciel de mathématiques intégré
Xcas
par , enseignant-chercheur à l'Université de Grenoble.

L'environnement est également programmable avec une syntaxe proche du
Python
. Pas de fonctions pour contrôler individuellement les pixels ici, mais par contre nous y disposons d'une tortue dont on peut spécifier les déplacements en pixels. Tentons de tracer un rectangle le plus grand possible à l'aide du code suivant :
Code: Select all
def scrtest(w, h):
  efface
  leve_crayon
  tourne_gauche 180
  avance w // 3
  tourne_gauche 90
  avance h // 2
  baisse_crayon
  for k in range(2):
    tourne_gauche 90
    avance w
    tourne_gauche 90
    avance h

C'est l'appel scrtest(383, 191) qui nous permet de rentrer le plus grand rectangle possible dans l'écran. Comme les paramètres concernent ici des déplacements de la tortue cela correspond à une zone graphique de
384×192= 73728
, soit exactement comme avec l'application
Python
officielle.


Casio Graph 25+E II
, ancienne
Graph 25+E
,
Graph 35+E II
, ancienne
Graph 35+E
et
Graph 75+E
utilisent des écrans de
128×64= 8192
pixels.

Casio Graph 25+E II
,
Graph 35+E II
et
Graph 35+E
partagent le même écran aux cristaux liquides noirs agréablement contrastés.
Comme vu en épisode 1, le superbe écran de la
Graph 75+E
a l'avantage d'être sensiblement plus grand.
Il bénéficie en prime d'un éclairage optionnel.

L'ancienne
Graph 25+E
à la différence bénéficie d'un écran nettement plus petit.
Précisons surtout que l'écran utilise des cristaux liquides bleus qui donnent un assez mauvais contraste, nuisant beaucoup à la lisibilité.

En appliquant le même programme de test que sur
Graph 90+E
, nous obtenons une zone graphique historique utilisable de
127×63= 8001
pixels soit
97,67%
.

Passons maintenant à l'application
Python
, ce qui ne concerne que la
Graph 35+E II
.

Ici c'est fantastique, nous contrôlons apparemment
100%
de l'écran, soit
128×64= 8192
pixels.


La
Graph 35+E II
te permet en prime d'installer l'application , adaptation dédiée du logiciel de mathématiques intégré
Xcas
par , un environnement programmable avec une syntaxe proche du
Python
.

Très similaire à celle pour
Graph 90+E
on peut donc tester ce qu'elle offre de la même façon. C'est l'appel scrtest(127, 63) qui nous permet d'inscrire le plus grand rectangle dans l'écran, ce qui correspond donc ici encore à
128×64= 8192
pixels.


11396La
Casio fx-92+ Spéciale Collège
intègre un contrôleur écran gérant
192×64= 12288
pixels.
En réalité son écran est hybride, avec :
  • une zone matricielle de
    192×63= 12096
    pixels
  • 20
    drapeaux indicatifs en haut d'écran, assimilables à des pixels mais aux formes non élémentaires
Nous sommes finalement sur un fantastique écran monochrome de
192×63+20= 12116
pixels.

La calculatrice est programmable dans un langage orienté tracé, avec des déplacements spécifiés en pixels. Nous pouvons donc ici encore tenter de dessiner un rectangle le plus grand possible.
Code: Select all
?→A
?→B
Stylo relevé
Tourner de ↺ 180 degrés
Avancer de Ent(A÷2pixels
Tourner de ↺ 90 degrés
Avancer de Ent(B÷2pixels
Stylo écrit
Répéter 2
  Tourner de ↺ 90 degrés
  Avancer de A pixels
  Tourner de ↺ 90 degrés
  Avancer de B pixels

C'est en saisissant
191
et
46
que l'on arrive à tracer le plus grand rectangle, ce qui correspond donc à une zone graphique contrôlable de
192×47= 9024
pixels, soit
74,48%
.


Les
TI-Nspire
, qu'elles soient à écran couleur ou monochrome, nous offrent toutes
320×240= 76800
pixels.

Pour déterminer la zone graphique utile, on peut utiliser un script
Lua
dimensionné en pleine page :
Code: Select all
function on.paint(gc)
  w = platform.window
  s = tostring(w.width()) .. "x" .. tostring(w.height())
  gc:drawString(s, 0, 0)

Les scripts
Lua
contrôlent donc jusqu'à
318×212= 67416
pixels soit
87,78%
.

A compter de la version système
5.0
avec les
TI-Nspire CX II
, le langage de programmation orienté fonctions historique s'enrichit de commandes graphiques dessinant dans une zone cette fois-ci non redimensionnable, mais qui fait elle aussi
318×212= 67416
pixels.

Nous ne disposons toujours pas de préversion de la future mise à jour
TI-Nspire CX II
avec
Python
, mais nous supposons que ce sera à nouveau la même zone graphique :
318×212= 67416
pixels.

Sur les
TI-Nspire
monochromes, ainsi que les anciennes
TI-Nspire CX
si non encore mises à jour en version
4.5.1
ou supérieure, il est possible d'y installer puis ensuite .
On y contrôle alors
100%
de l'écran, soit
320×240= 76800
pixels. :bj:

Sur les anciennes
TI-Nspire CX
,
Ndless
permet également l'installation d'une version de intégrant une version étendue de ce même interpréteur
Python
.
Notre script universel de test détecte ici un peu moins,
320×222= 71040
pixels pouvant à la fois être lus et écrits.


La
NumWorks
t'apporte un écran de
320×240= 76800
pixels.

Pour les graphes nous n'avons pas trouvé de moyen automatique de mesurer la fenêtre graphique. Alors tant pis comptons les pixels à la main, ci-contre
320×156= 49920
pixels.

L'application
Python
quant à elle te permet de contrôler
320×222= 71040
pixels.

Si tu installes le
firmware
tiers
Omega
, tu peux ensuite installer une application
KhiCAS
intégrant son propre interpréteur
MicroPython
. Mais pas de changement, ici encore c'est
320×222= 71040
pixels.


La
HP Prime
t'offre un écran de
320×240= 76800
pixels.

Le mode
CAS
y disposant d'une compatibilité syntaxique
Python
, il est possible d'y exécuter directement notre script de test.

La compatibilité est très loin d'être automatique, il y a nombre de contraintes à respecter dans l'écriture, mais notre script a été conçu dès le départ en en tenant compte. Si tu y vois des blocs pas très optimisés, c'est pour ça. ;)

320×240= 76800
pixels sont donc à disposition pour tes programmes, soit
100%
! :bj:

Pas possible de tester de la même façon l'application
Python
de la version
alpha
publiée par erreur en
octobre 2019
. En effet son module
prime
y transcrit bien la fonction graphique historique
pixon()
pour écrire des pixels, mais pas encore la fonction
getpix()
pour les lire. :'(

Toutefois jusqu'à présent tous les constructeurs ont proposé dans leur
Python
officiel une zone graphique identique ou plus étendue que celle de leurs graphiques et programmes en langage historique, c'est probablement ici encore
320×240= 76800
, ce que l'on confirme en allumant quelques pixels aux frontières de l'écran.


La
Casio fx-CP400+E
inclut niveau définition de loin le meilleur écran tous modèles confondus,
320×528= 168960
pixels. :bj:

Niveau zone graphique utile maintenant, c'est compliqué.

En orientation portrait nous avons par défaut
309×185= 57165
pixels.

Si tu te donnes la peine de redimensionner la fenêtre graphique en pleine page, ce seront
309×401= 123909
pixels.

Tu peux également utiliser ta calculatrice en orientation paysage. Mais pas d'accéléromètre ici et donc rien d'automatique, c'est un bouton tactile physique à côté de l'écran qui est à utiliser à chaque fois que tu éprouves le besoin de changer l'orientation, un peu comme sur la console portable
Lynx
d'
Atari
.

Par défaut tu disposes dans ce sens d'une zone graphique de
517×81= 41877
pixels, une zone que nous trouvons bien trop écrasée et donc peu adaptée à étudier autre chose que des fonctions trigonométriques.

Si tu redimensionnes en pleine page, tu peux étendre la chose à
517×193= 99781
pixels :


Bref, que retenir de tout ça pour confrontation à la concurrence ?

Déjà on peut préciser qu'il est impossible d'exécuter des programmes en orientation paysage, donc autant prendre l'orientation portrait commune.
Optons donc pour les
309×401= 123909
pixels, soit
73,33%
.


Enfin, si
Maman
revient des courses de rentrée avec une
Esquisse GCEXFR
ou
Lexibook GC3000FR
, tu auras sans doute à t'interroger sur le sens caché de ce message d'une extrême violence. :troll:

Le
packaging
est mensonger, te présentant via un
sticker
un écran à cristaux liquides noirs, qui se transforme une fois allumé en cristaux liquides bleus fort mal contrastés et ainsi désagréables à lire, et contrairement à tous les modèles précédents aucune fonctionnalité n'a été prévue pour en régler le contraste ! :mj:
11403846411490


1149211491L'écran n'est pas matriciel mais hybride. Tellement dur à lire que pour mieux t'en détailler l'intégralité des capacités nous t'avons fait un petit montage ci-contre.
Nous avons donc :
  • une zone matricielle dédiée aux graphiques de
    47×32= 1504
    pixels en bas à gauche soit un timbre poste, littéralement... :#roll#:
  • une zone matricielle complémentaire de pixels
    40×8= 320
    pixels en bas à droite, qui par juxtaposition permet la saisie de tes calculs et l'affichage de leurs résultats sur 87 pixels de largeur
  • 2 afficheurs numériques à 7 segments dédiés à l'affichage des exposants de 10 pour les résultats en notation scientifique
  • 19 autres drapeaux de formes diverses
Il s'agit donc d'un écran assimilable à du
47×32+40×8+2×7+19= 1857
pixels.

Que contrôle-t-on dans tout ça ? Déjà pas grand chose car la machine n'est pas programmable malgré la présence trompeuse d'une touche
PROG
au clavier, une inadéquation manifeste aux programmes scolaires, et encore ce n'est même pas le pire de ses défauts de ce point de vue... :#roll#:

12780Bref pour tester la zone graphique
(in)
utile, il ne nous reste plus que les graphiques. Par défaut nous avons donc un repère orthonormal, avec un pas de 0.2 entre deux pixels horizontaux ou verticaux.
Récupérons les bornes de la fenêtre, une par une car la technologie archaïque qu'il semble y avoir sous le capot est incapable d'afficher simultanément plusieurs nombres à l'écran :
12776127771277812779

Allons-y pour les calculs :
  • $mathjax$\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1=\frac{\left(4.6+4.6\right)}{0.2}+1\\
    \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=\frac{9.2}{0.2}+1\\
    \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=46+1\\
    \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=47$mathjax$
  • $mathjax$\frac{\left(3-\left(-3\right)\right)}{0.2}+1=\frac{\left(3+3\right)}{0.2}+1\\
    \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=\frac{6}{0.2}+1\\
    \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=30+1\\
    \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=31$mathjax$
11499Zone graphique utilisable donc de
47×31= 1457
pixels.
Oui, la zone matricielle correspondant sur l'écran faisant 32 pixels de hauteur, il y a donc physiquement et bêtement une ligne de 47 pixels qui ne s'allument jamais... :o

Ce qui nous permet en passant de dénoncer un autre mensonge de l'emballage et du manuel, si tu comptes bien la sinusoïde donnée en exemple y est en effet tracée sur une zone graphique
48×32= 1536
pixels, soit une surestimation de plus de 5%... Forcément avec ça, la sinusoïde réellement obtenue est loin d'être aussi belle que celle de l'emballage... :#roll#:
8498


Comment peut-on avoir un
packaging
aussi mensonger, aussi trompeur, sans le faire exprès ?... Ce ne sont plus des astuces
marketing
là, c'est de l'arnaque pure et simple, les marques concernées regorgent visiblement de grands talents dans ce domaine... des pratiques irrespectueuses du consommateur et dans tous les cas indignes de notre pays, un crime contre la jeunesse, contre l'éducation et donc contre l'avenir, et par conséquent contre l'humanité ! :mj:




Résumé donc des capacités des différents écrans, avec :
  • en bas les capacités officielles de la machine en mode examen
  • en haut les possibilités hors mode examen




Crédits images
:
bande dessinée

TI-z80 Journées d'été T3, formation en ligne rentrée 2020 par TI

New postby critor » 18 Aug 2020, 13:09

L'année dernière,
Texas Instruments
avait accompagné les enseignants dans la prise en main de la nouvelle
TI-83 Premium CE Edition Python
dans le cadre de ses
journées d'été TI-Python
.
Une formation de 2 jours organisée la semaine d'avant la rentrée dans pas moins de 7 villes de France métropolitaine, et qui avait bénéficié d'un succès phénoménal, la calculatrice étant en prime fournie et offerte aux participants accompagnée de ses supports de formation et d'activités ! :bj:

L'épidémie étant passée par là entre temps, il n'est hélas pas possible d'organiser le même genre d'événement cette année.

Toutefois ne t'inquiète pas,
Texas Instruments
ne te laisse pas tomber pour autant, et a prévu en remplacement quelque chose de différent pour cette rentrée 2020, les
Journées d’été T³
. :D

Cet événement organisé cette année en ligne, sera l'occasion de se former en
Python
dans le contexte de nouveaux produits compatibles de la marque ainsi que des nouveaux programmes du lycée général et technique et même du lycée professionnel ! :bj:

Au menu les nouveautés de la dernière mise à jour
5.5.2
pour
TI-83 Premium CE Edition Python
:
  • jeudi 27 août :
    17h45-19h00
  • vendredi 28 août :
    17h45-19h00

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

Source
:
https://twitter.com/TIEducationFR/statu ... 44/photo/1

Casio Mise à jour matplotlib Casio Graph 90/35+E II : arrow()

New postby critor » 18 Aug 2020, 10:30

Pour cette rentrée 2020, la formidable application
Python
des
Casio Graph 90+E
et
Graph 35+E II
si correctement mise à jour
(ce qu'il est notamment conseillé de faire si tu viens d'acheter la calculatrice)
t'offre 3 modules importables pour tes scripts :
  • math
    pour les fonctions mathématiques, un standard
  • random
    pour l'aléatoire, un standard
  • et
    casioplot
    , un module graphique propriétaire permettant à tes scripts d'allumer des pixels de l'écran dans la couleur de ton choix

De plus,
Casio
diffuse 2 scripts
Python
à rajouter manuellement dans ta calculatrice et qui s'appuient sur le module
casioplot
précédent :
  • turtle.py
    , un script fantastique de plus de 300 lignes qui reproduit sur ta calculatrice le fonctionnement du module
    turtle
    standard
  • matplotl.py
    , un script monumental de plus de 600 lignes qui s'occupe quant à lui de reproduire sur ta calculatrice le fonctionnement du module standard
    matplotlib.pyplot
Il s'agit donc de réimplémentations en
Python
des modules standard
turtle
et
matplotlib.pyplot
, un travail à la fois colossal et d'excellente facture, car hautement fidèle aux modules standard en question ! :bj:

Tous les liens de téléchargement seront disponibles en fin d'article.


12775Cela n'enlève rien à leurs énormes qualités supérieures par rapport à ce qui est disponible sur certaines
Pythonnettes
concurrentes, mais une réécriture intégrale ne peut pas être parfaite du premier coup.

Nous nous intéresserons ici au script
matplotl.py
, et plus précisément à sa fonction de tracé de flèche/vecteur notamment pour l'enseignement de
Physique-Chimie
en
Seconde
,
arrow()
.
Absolument pas pour se moquer de
Casio
, mais simplement parce que c'est intéressant et hautement formateur.

Voici un petit script avec de quoi te tracer un soleil de vecteurs
(ou un champ de vecteurs radial pour ceux qui préfèrent)
:
Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *
from math import cos, sin, pi

def radians(x):
  return x * pi / 180

def autoround(x):
  xr = round(x, 0)
  if abs(x - xr) < 10 ** -15:
    x = xr
  return x

def rotarrow(x0, y0, rx, ry, t1, t2, ts, hw, hl, ec, fc):
  for k in range(t1, t2 + ts, ts):
    kr = radians(k)
    w, h = autoround(rx * cos(kr)), autoround(ry * sin(kr))
    arrow(x0, y0, w, h, head_width=hw, head_length=hl, ec=ec, fc=fc)

Graph 35+E II
Graph 90+E
NumWorks
ordi
Code: Select all
rotarrow(.0625, .0625, .75, .75, 0, 90, 10, .075, .1875, 'r', 'b')
show()

Bon la
NumWorks
semble ignorer les paramètres de couleur pour faire absolument n'importe quoi, mais ce n'est pas ce qui nous intéresse aujourd'hui. Voyons donc plutôt les défauts chez
Casio
.

Sur
Graph 35+E II
tout semble bon. Par contre sur
Graph 90+E
il y a un problème avec la couleur des pointes, dans le cas particulier où elles sont orientées horizontalement ou verticalement.

Effectivement ça ne va pas, tentons de comprendre et corriger directement le fichier de
Casio
puisque ce dernier a eu la gentillesse de laisser le code source consultable et modifiable contrairement à d'autres. ;)

La variable
color
est donc la couleur utilisée pour le tracé du segment via un appel
plot()
commun à toutes les orientations.
La variable
headcolor
est quant à elle la couleur souhaitée pour la pointe.
Pour le tracé de la pointe il y a 2 cas particuliers pour les directions horizontales et verticales, et effectivement les appels
plot()
associés sont faux, réutilisant
color
comme paramètre de couleur. La correction est triviale, lignes n°23 et 29 dans les extraits de code ci-dessous : :)
maptplotl.py

de
Casio
matplotl.py

corrigé
Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),color)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),color)
Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),headcolor)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),headcolor)


Bon mais ça c'était un détail. Voici maintenant beaucoup plus dérangeant et épicé : ;)
Graph 35+E II
Graph 90+E
NumWorks
ordi
Code: Select all
rotarrow(.475, .5, .45, .4, 0, 360, 10, .05, .1, 'r', 'b')
axis([0, 1, 0, 1])
show()

Mais sur
Graph 35+E II
et
Graph 90+E
ça ne va pas du tout... Mais qu'est-ce que c'est que cette horreur de soleil à moitié fané ?... :#roll#:

Dans certains cas, les pointes de flèches/vecteurs sont visiblement tracées à l'envers. Là pour le coup c'est un
bug
bien plus profond et non une simple étourderie.

Tentons de comprendre un peu mieux quand est-ce que cela se produit :
Graph 35+E II
Graph 90+E
NumWorks
ordi
Code: Select all
for k in range(4):
  rotarrow(.475 - (k <= 1), .5 - (k % 2), .45, .4, 0, 360, 15, .075, .1, 'r', 'b')
axis([-1, 1, -1, 1])
show()

Il semble que les pointes de flèches soient ainsi montées à l'envers lorsqu'elles ont une abscisse négative
(x<0)
. Il s'agirait donc a priori d'une erreur de signe, faut-il encore trouver où changer le signe dans le code.

Notons que le problème concerne des flèches qui ne sont ni horizontales ni verticales, et l'erreur est donc à chercher cette fois-ci dans le bloc traitant le cas général. Or il y a justement un test de signe dans ce cas, ligne 34 ci-dessous. Changeons cela... ;)
maptplotl.py

de
Casio
matplotl.py

corrigé






Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),headcolor)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),headcolor)
    else:
        m=dy/dx
        p=y-m*x
        S=resol(m**2+1,2*(-a-b*m+m*p),p**2+a**2+b**2-l**2-2*b*p)
        if S[0]*dx<0:
            X=S[0]
        else:
            X=S[1]
        Y=m*X+p
        k=b+a/m
        T=resol(1+1/m**2,2*(-a-k/m+b/m),a**2+k**2-2*b*k+b**2-(L**2)/4)
        plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)
Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),headcolor)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),headcolor)
    else:
        m=dy/dx
        p=y-m*x
        S=resol(m**2+1,2*(-a-b*m+m*p),p**2+a**2+b**2-l**2-2*b*p)
        if S[0]*dx*x<0:
            X=S[0]
        else:
            X=S[1]
        Y=m*X+p
        k=b+a/m
        T=resol(1+1/m**2,2*(-a-k/m+b/m),a**2+k**2-2*b*k+b**2-(L**2)/4)
        plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)

Ah ben non, ce n'est pas encore ça... cela corrige bien les pointes enfichées sur une extrémité de segment d'abscisse négative, mais pas celles qui franchissent l'axe des ordonnées donnant donc une pointe d'abscisse négative bien que montée sur une extrémité d'abscisse positive.

Les deux sens de montage de la flèche pour l'orientation du segment sont en fait retournées en abscisses par un appel
resol()
, simple fonction donnant les racines d'un polynôme du second degré.

Reste donc à choisir le bon sens de montage, et le test officiel S[0]*dx<0 ainsi que notre test S[0]*dx*x<0 semblent donc tous les deux faux.

En fait nous ne voyons même pas en quoi la réponse dépendrait du signe de la racine S[0]... à la rigueur de l'ordre de S[0] et S[1] pour savoir qui est à gauche et qui est à droite, mais pas du signe... et ici il n'y a même pas à se préoccuper de l'ordre puisque 1+1/m**2, premier paramètre de l'appel
resol()
, est strictement positif.

Faire pointer à gauche ou à droite, non ici cela ne dépend plus que d'une seule et unique chose, le signe de
dx
, et le bon test corrigé en ligne 34 ci-dessous est donc dx<0.
On peut bien se permettre une petite coquille après s'être tapé plus de 320 lignes. ;)

maptplotl.py

de
Casio
matplotl.py

corrigé






Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),headcolor)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),headcolor)
    else:
        m=dy/dx
        p=y-m*x
        S=resol(m**2+1,2*(-a-b*m+m*p),p**2+a**2+b**2-l**2-2*b*p)
        if S[0]*dx<0:
            X=S[0]
        else:
            X=S[1]
        Y=m*X+p
        k=b+a/m
        T=resol(1+1/m**2,2*(-a-k/m+b/m),a**2+k**2-2*b*k+b**2-(L**2)/4)
        plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)
Code: Select all
def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a=x+dx
    b=y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc',color)
    headcolor=kwargs.get('facecolor',headcolor)
    L=kwargs.get('head_width',0.003)
    l=kwargs.get('head_length',1.5*L)
    plot((x,a),(y,b),color)

    def resol(A,B,C):
        D=B**2-4*A*C
        if D>0:
            return((-B-D**0.5)/(2*A),(-B+D**0.5)/(2*A))
    if dx==0:
        if dy>=0:
            c=1
        else:
            c=-1
        plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+c*l,b),headcolor)
    elif dy==0:
        if dx>=0:
            c=1
        else:
            c=-1
        plot((a,a,a+c*l,a),(b-L/2,b+L/2,b,b-L/2),headcolor)
    else:
        m=dy/dx
        p=y-m*x
        S=resol(m**2+1,2*(-a-b*m+m*p),p**2+a**2+b**2-l**2-2*b*p)
        if dx<0:
            X=S[0]
        else:
            X=S[1]
        Y=m*X+p
        k=b+a/m
        T=resol(1+1/m**2,2*(-a-k/m+b/m),a**2+k**2-2*b*k+b**2-(L**2)/4)
        plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)

En attendant une mise à jour officielle qui réglera cela et peut-être d'autres choses, c'est donc cette version corrigée que nous distribuerons.


Téléchargements
:


NumWorks Rentrée 2020, la NumWorks disponible chez Carrefour !

New postby critor » 17 Aug 2020, 17:14

12695Lors de sa sortie à la rentrée 2017, la calculatrice
NumWorks
se commercialisait exclusivement en ligne, dans la boutique du constructeur ainsi que sur
Amazon
, à
79,99€
frais de port inclus ! :bj:

Depuis la disponibilité en ligne s'est élargie. On compte aujourd'hui en prime dans le même ordre de prix :
Comme déjà annoncé nous avons également le distributeur scolaire historique de
Texas Instruments
,
Jarrety
, qui passe à la concurrence
Casio
et
NumWorks
pour cette rentrée 2020, mais bizarrement par son intermédiaire c'est beaucoup plus cher, pas moins de
89,89€
, certes toujours port inclus :
https://jarrety.fr/lycee/65-numworks.html

Quant aux boutiques physiques, nous avions déjà vu la calculatrice
NumWorks
en librairie
Gibert Joseph
, mais comme ce dernier beaucoup plus chère que si achetée en ligne chez
NumWorks / Amazon / fnac
avec le port inclus, alors que paradoxalement pour les boutiques physiques il te faudra d'une façon ou d'une autre payer ton déplacement et éventuellement ton stationnement.

Dans un article précédent, nous t'annoncions que pour cette rentrée 2020 la
NumWorks
était enfin disponible en boutiques spécialisées, plus précisément à la
fnac
et ici à la différence à seulement
79,99€
comme chez le constructeur ! :bj:

1277412773Et bien ce n'est pas fini, 2020 est vraiment la rentrée de la démocratisation de la
NumWorks
, la calculatrice est enfin disponible en grande surface, s'y affichant fièrement à côté de la concurrence ! :bj:

Nous sommes allés voir suite à une information communiquée par , ici nous sommes donc chez
Carrefour
, et comme tu vois sans aucun surcoût à
79,99€
comme en ligne ! :D
Petite remarque par contre, l'emballage n'est clairement pas conçu pour une exposition en rayon, pas sûr que ça donne envie à tout-le-monde...


Après 3 ans d'attente pour
2020-2021
, la
NumWorks
est enfin disponible près de chez toi, et ainsi accessible à toutes et tous ! :favorite:
Les enseignants peuvent donc librement la recommander, sans se sentir obligés d'organiser une commande groupée.

Divers QCC 2020 épisode 6 : Constantes physiques

New postby critor » 16 Aug 2020, 20:45

5409
Quelle Calculatrice programmable Choisir 2020


Episode 6 - Constantes physiques




Cette année il y a du nouveau au niveau des bibliothèques de constantes physiques ; voyons donc ce qu'offrent les calculatrices graphiques conformes ou se disant conformes 2021.

Si jamais tu avais opté pour un modèle dépourvu d'une telle bibliothèque, tu pouvais jusqu'à présent télécharger gratuitement des programmes en rajoutant.
Hélas, c'est désormais impossible à cause du mode examen à diode qui sera mis en place pour la première fois de façon nationale à l'occasion des épreuves d'examen 2020-2021, un mode qui désactive tout ce que tu auras rajouté.

Il ne faut donc pas te tromper dans ton achat cette année, particulièrement si tu envisages une coloration sciences expérimentales de ton orientation.



Déjà, commençons par dénoncer les modèles dépourvus à l'achat d'une bibliothèque de constantes physiques, et sans aucune solution à ce jour :
  • l'
    Esquisse GCEXFR
  • la
    Lexibook GC3000FR
  • la
    Casio Graph 25+E
  • la
    Casio Graph 25+E II
114038493518112581

Sur les
TI-83 Premium CE
et
TI-83 Premium CE Edition Python
, la bibliothèque de constantes physiques est apportée par l'application
(outils scientifiques)
, venant préchargée dans les calculatrices neuves.
Si jamais cette application a été effacée, il suffit juste de la retélécharger et réinstaller gratuitement. :)

15
constantes physiques y sont disponibles, avec pour chacune : description, symbole et unité ! :bj:
Les symboles toutefois ne sont pas toujours standard.

Le menu de bas d'écran
EXPT
permettra d'exporter la valeur numérique intégrale vers la ligne de saisie de l'écran de calculs.
Les constantes ont ainsi le défaut de ne pas pouvoir être appelées automatiquement depuis un calcul ou un programme.

On peut ainsi déplorer l'impossibilité pour un programme de récupérer automatiquement une valeur de constante.

Bref il n'y a donc ici pas beaucoup de constantes ; mais la quantité ne fait pas tout. ;)
Pour cette rentrée 2020, l'application bénéficie d'une mise à jour
5.5
avec des corrections de valeurs de certaines constantes.

Tentons donc d'évaluer la précision de cette bibliothèque. Nous allons nous baser pour cela sur les valeurs de 8 constantes communes à toutes les solutions que nous allons te présenter :
  • e :
    charge élémentaire
  • G :
    constante de gravitation universelle
  • h :
    constante de Planck
  • k :
    constante de Boltzmann
  • me :
    masse de l'électron
  • mp :
    masse du proton
  • NA :
    nombre d'Avogadro
  • R :
    constante universelle des gaz parfaits

Nous prendrons comme référence les valeurs officielles du
CODATA
(Comité de données pour la science et la technologie)
, dont la dernière mise à jour date de 2018 :
CODATA 2018
.

Voici un petit script
Python
auquel il suffira de fournir les chiffres significatifs des constantes de la calculatrice pour obtenir les écarts relatifs de chacune ainsi que l'écart relatif moyen :
Code: Select all
from math import log

def mean(l):
  return sum(l)/len(l)

def error_r(name, val):
  data = (
    ['c',  299792458, 0],
    ['e',  1602176634, -19],
    ['G',  667430, -11],
    ['g',  980665, 0],
    ['h',  662607015, -34],
    ['k',  1380649, -23],
    ['me', 91093837015, -31],
    ['mn', 167492749804, -27],
    ['mp', 167262192369, -27],
    ['NA', 602214076, 23],
    ['R',  8314462618, 0],
    ['u',  166053906660, -27],
  )
  for vref in data:
    if vref[0] == name:
      break
  if vref[0] == name:
    while int(log(val, 10)) < int(log(vref[1] , 10)):
      val *= 10
    while int(log(val, 10)) > int(log(vref[1] , 10)):
      vref[1] *= 10
    return abs(val - vref[1]) / vref[1]

def error_m(l):
  lerr = []
  for v in l:
    err = error_r(v[0], v[1])
    lerr.append(err)
    print(v[0], err)
  return mean(lerr)


Recopions donc les valeurs fournies par la calculatrice dans notre appel, avec l'ancienne puis la nouvelle version :
Code: Select all
error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Code: Select all
error_m([
  ['e',  1602176634],
  ['G',  66743],
  ['h',  662607015],
  ['k',  1380649],
  ['me', 91093837015],
  ['mp', 167262192369],
  ['NA', 602214076],
  ['R',  8314462618],
])

C'est extraordinaire, quel formidable travail de veille scientifique chez
Texas Instruments
.
L'écart relatif moyen passe de
0,000869%
avec la version précédente de l'application à
0%
cette année ; c'est-à-dire que toutes les constantes testées sont exactes ! :bj:

Plus précisément la mise à jour nous fait passer des valeurs aux valeurs
CODATA 2018
.
Texas Instruments
avait donc pris pas mal de retard mais s'est finalement bien rattrapé. :)

Candidats scolarisés hors de France, attention.

La
TI-84 Plus CE-T
distribuée dans le reste des pays européens interdira l'accès à l'application
SciTools
une fois passée en mode examen ! :#non#:

Même problème pour la
TI-84 Plus T
monochrome. :mj:

Accessoirement ce modèle n'a jamais bénéficié de la moindre mise à jour depuis sa sortie pour la rentrée 2016. Les valeurs utilisées sont donc plus anciennes, avec ici un écart relatif moyen de
0,00247%
: :(
Code: Select all
error_m([
  ['e',  1602176462],
  ['G',  6673],
  ['h',  662606876],
  ['k',  13806503],
  ['me', 910938188],
  ['mp', 167262158],
  ['NA', 602214199],
  ['R',  8314472],
])

Il s'agit en fait de valeurs beaucoup plus anciennes correspondant à la base de données .
C'est-à-dire que
Texas Instruments
semble n'avoir jamais mis à jour les données de l'application
SciTools
pour
TI-82/83/84+
depuis le lancement de cette gamme avec la
TI-83 Plus
en 1999, et avoir utilisé la même application pour la
TI-84 Plus T
en 2016 sans aucun rafraîchissement du contenu.


La
TI-82 Advanced
monochrome ne dispose hélas pas de l'application
SciTools
.
Il est certes possible d'installer des applications
TI-82/83/84 Plus
et même d'y conserver l'accès en mode examen...
Mais les applications installées via cette méthode doivent faire moins de
16 Kio
et est hélas beaucoup trop gros. :'(

Par contre, on peut installer l'application qui inclut une petite bibliothèque de
13
constantes, et aura le gros avantage de rester disponible en mode examen.

Ici on récupère les valeurs de constantes en résultat, et elles ont ainsi le gros avantage de pouvoir être directement appelées depuis un programme.
Par contre pas d'unités ni de description, et les symboles se permettent diverses fantaisies.

Cette application a été mise à jour pour la dernière fois en 2004, donc les valeurs seront ici bien plus obsolètes.
Notons que comme les valeurs étant récupérées en résultat, tous leurs chiffres significatifs ne sont pas forcément affichés.
Voici un petit programme
TI-Basic
afin d'extraire tous les chiffres significatifs du dernier résultat :
Code: Select all
abs(Rep→X
" →Chn1
"0123456789→Chn0
While partDéc(X
  10X→X
End
While X≥10
  X/10→X
End
While X
  ent(X→I
  10partDéc(X→X
  Chn1+sousch(Chn0,I+1,1→Chn1
End
Chn1

Mais en fait non, les constantes sont tellement peu précises ici qu'il n'y a pas de chiffre significatif masqué.

Ici l'erreur relative moyenne est ainsi de
0,00396%
:
Code: Select all
print(error_m([
  ['e',  160217733],
  ['G',  667259],
  ['h',  66260755],
  ['k',  1380658],
  ['me', 91093897],
  ['mp', 16726231],
  ['NA', 60221367],
  ['R',  831451],
]))

En fait, c'est encore pire que ce que l'on pensait, les valeurs correspondent à la banque ...


La
Casio Graph 90+E
dispose d'une application officielle préchargée qui apporte une bibliothèque de constantes.

Attention, cette application sera inaccessible en mode examen. :#non#:

Pas moins de
39
constantes sont ici disponibles avec leurs symboles et, sur demande, descriptions et unités.

Un gros avantage par contre ici, est que l'on peut modifier les constantes pour s'adapter par exemple à la valeur fournie par un énoncé, et les réinitialiser automatiquement pas la suite.

Pas de possibilité d'appel automatique depuis un programme, par contre l'interface permet de stocker directement la valeur sélectionnée dans une variable de la calculatrice.

Voici de quoi extraire l'ensemble des chiffres significatifs des variables en question :
Code: Select all
?→X
Abs X→X
""→Str 1
"0123456789"→Str 10
While Frac X
  10X→X
WhileEnd
While X≥10
  X÷10→X
End
While X
  Int X→I
  10Frac X→X
  StrJoin(Str 1,StrMid(Str 10,I+1,1))→Str 1
WhileEnd
Locate 1,1,Str 1


Une fois l'ensemble des chiffres significatifs récupérés, nous trouvons ici
0,000422%
d'erreur relative moyenne :
Code: Select all
error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Il s'agit ici des valeurs .

Physium
est tout autant disponible pour
Casio fx-CP400+E
, avec les mêmes valeurs et quasiment les mêmes capacités.

Seule et unique chose que nous ne trouvons pas ici, la possibilité de modifier les constantes.


Ici encore, plus rien en mode examen.

Physium
est également disponible pour les
Casio Graph 35+E II
et
Graph 75+E
monochrome avec exactement les mêmes capacités.

Toujours aussi interdite en mode examen.

L'application passe cette année à la nouvelle version
1.13
, première mise à jour concernant la
Graph 75+E
depuis 2014 !

Le changement est que les constantes basculent sur les nouvelles valeurs qu'utilisaient déjà les versions couleur pour
Graph 90+E
et
fx-CP400+E
depuis des années, passant l'erreur relative moyenne de
0,000869%
à
0,000422%
:
Code: Select all
error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Code: Select all
error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Nous passons donc ici des valeurs aux valeurs .

Pour les anciennes
Casio Graph 35+E
il est possible de leur installer le système
Graph 75+E
pour ensuite leur rajouter l'application
Physium
.

Toutefois elle restera tout autant inaccessible en mode examen.


Les
TI-Nspire CX II CAS
, ainsi que les
TI-Nspire CX CAS
si mise à jour en version
4.5
ou supérieure t'offriront
24
constantes, toutes accompagnées de leurs descriptions et unités.
Leur nommage par contre n'est pas toujours très heureux par rapport à leur symbole, les constantes ayant le défaut d'utiliser le même préfixe que les unités.

Voici de quoi extraire l'ensemble des chiffres significatifs :
Code: Select all
Define fullnbr(x)=
Func
  Local s,i
  s:=""
  x:=abs(x)
  While fPart(x)≠0
    x:=10*x
  EndWhile
  While x≥10
    x:=((x)/(10))
  EndWhile
  While x≠0
    i:=int(x)
    x:=10*fPart(x)
    s:=s&mid(string(i),1,1)
  EndWhile
  Return s
EndFunc


Nous avons ici affaire aux données .

Les données de nos constantes une fois extraites en intégralité nous donnent une erreur relative moyenne de
0,000422%
:
Code: Select all
error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Les simples
TI-Nspire CX II-T
,
TI-Nspire CX II
et
TI-Nspire CX
si mise à jour en version
4.5
ou supérieure offriront la même bibliothèque de constantes, mais sans les unités.

La
TI-Nspire CAS TouchPad
quant à elle reprend l'intégralité des fonctionnalités, mais avec le jeu de données beaucoup plus ancien du , pour une erreur relative moyenne de
0,000869%
:
Code: Select all
error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Sur les simples
TI-Nspire TouchPad
et
TI-Nspire
, pas de bibliothèque de constantes physiques.

Tu peux toutefois leur rajouter une bibliothèque de constantes complète en installant le logiciel
KhiCAS
, permettant d'obtenir en prime les unités.

Pour les simples
TI-Nspire CX
il est en théorie également possible de leur installer un logiciel
KhiCAS
même un peu plus étendu.
Toutefois en pratique l'ajout de ces outils nécessite de commencer par installer . Or la plupart des
TI-Nspire CX
que tu trouveras seront préchargées avec une version
4.5.1
ou supérieure que
Ndless
ne gère toujours pas. :'(


KhiCAS
t'offre ici une bibliothèque de
27
constantes.

Les valeurs semblent toutefois être très anciennes, remontant au pour presque toutes celles que nous avons choisi de tester ici. Seule exception parmi notre sélection, la constante
G
qui correspond bizarrement au .

Ce qui nous donne donc ici une erreur relative moyenne intermédiaire de
0,000606%
.
Code: Select all
error_m([
  ['e',  160217733],
  ['G',  667408],
  ['h',  66260755],
  ['k',  1380658],
  ['me', 91093897],
  ['mp', 16726231],
  ['NA', 60221367],
  ['R',  831451],
])

Hélas tout ceci sera indisponible en mode examen.

Tu peux toutefois obtenir la bibliothèque officielle et ce même en mode examen sur tes
TI-Nspire TouchPad
et
TI-Nspire
, en installant directement le système
TI-Nspire CAS


Pour les simples
TI-Nspire CX
, de façon similaire il est en théorie possible de leur installer le système
TI-Nspire CX CAS
et donc d'accompagner les constantes d'unités.
Il suffit pour cela d'installer
nBoot
+
ControlX
si compatible, ou à défaut
nLoader
.
Toutefois en pratique l'ajout de ces outils nécessite ici encore de commencer par installer . Or comme la plupart des
TI-Nspire CX
que tu trouveras seront préchargées avec une version
4.5.1
ou supérieure... :'(


Sur
NumWorks
au commencement il n'y a rien. Toutefois tu peux installer très facilement le
firmware
tiers
Omega
.
Omega
reprend le
firmware
officiel tout en y faisant quelques ajouts, dont justement une bibliothèque de constantes physiques.

Nous excluons ici les constantes relatives aux atomes que nous compterons à part avec les applis de classification périodique des éléments, ce qui nous donne quand même un nombre formidable de
82
constantes ici, toutes avec description et unités.

Ici les valeurs sont copiées directement sur la ligne de saisie, ce qui interdit hélas tout accès automatique depuis un programme.

Quelques bizarreries également, les valeurs effectivement saisies ne correspondent pas toujours à celles des menus. Par exemple, la constante
R
des gaz parfaits perd son 4 final...

Les valeurs ne sont pas uniformes ici, semblant provenir de plusieurs sources et pas directement des banques
CODATA
officielles. Par exemple :
  • les constantes de Planck
    (
    h
    )
    , de Boltzmann
    (
    k
    )
    et nombre d'Avogadro
    (
    NA
    )
    proviennent du
    CODATA 2018
  • la constante de gravitation universelle
    (
    G
    )
    et la charge élémentaire
    (
    e
    )
    semblent être des troncatures des valeurs du
  • la masse de l'électron
    (
    me
    )
    semble être une troncature de la valeur du
    CODATA 2018
  • la masse du proton
    (
    mp
    )
    semble être un arrondi de la valeur du
  • la constante des gaz parfaits
    (
    R
    )
    semblerait correspondre à la valeur du
    CODATA 2018
    , mais bizarrement avec des chiffres en plus cette fois-ci...

Tout ceci se ressent bien évidemment dans notre mesure de la pertinence des valeurs, avec ici
0,000765%
d'erreur relative moyenne :
Code: Select all
error_m([
  ['e',  160217662],
  ['G',  6674],
  ['h',  662607015],
  ['k',  1380649],
  ['me', 9109383],
  ['mp', 1672649],
  ['NA', 602214076],
  ['R',  83144626181532],
])

Précisons qu'
Omega
te permet à son tour d'installer l'application
KhiCAS
, avec les mêmes
27
constantes et capacités que pour l'édition
TI-Nspire
.

Mais grosse différence ici,
KhiCAS
restera disponible en mode examen ! :bj:

Enfin terminons avec la
HP Prime
. On y accède aux constantes via le menu
Const
affiché par
Shift
Units
.
Décocher
Valeur
permet d'obtenir les unités, et quant à la description on la récupère avec la touche
Help
.
En excluant les constantes mathématiques, nous obtenons ici un total de
21
constantes physiques ! :bj:

Il s'agit des valeurs du , avec donc
0,000422%
d'erreur relative moyenne :
Code: Select all
error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])


Précisons de plus que si tu bascules ta calculatrice en mode calcul formel avec la touche
CAS
, tu auras accès aux
27
constantes de
KhiCAS
déjà couvertes plus haut dans le contexte des
TI-Nspire
et
NumWorks
. Avec ici le gros avantage de pouvoir les appeler automatiquement depuis un programme.





Résumé des données, avec :
  • en bas les fonctionnalités officielles présentes à l'achat et persistant en mode examen
  • en haut l'ensemble des possibilités avec améliorations et/ou hors mode examen
Link to topic: QCC 2020 épisode 6 : Constantes physiques (Comments: 3)

TI-z80 Broken Holyxe World, le monde perso Oiram CE revisité

New postby critor » 16 Aug 2020, 14:49

12495Ta formidable
TI-83 Premium CE
dispose disposait d'une pièce maîtresse sur la scène vidéo-ludique qui a pu expliquer jusqu'à présent son succès extraordinaire en France, le dénommé
Oiram CE
.

Publié en
janvier 2017
par , il s'agit d'un moteur de jeux
Mario-like
, bénéficiant d'une formidable bibliothèque de pas moins de 81 packs de niveaux perso, dont d'excellents
remakes
de ,
Super Mario Bros 2 / Super Mario Bros The Lost Levels
mondes 1-8 et mondes 9-13,
Super Mario Bros 3
mondes 1-2 et monde 3,
New Super Mario Bros
...
Attention, une réalisation aussi exceptionnelle que
Oiram CE
nécessite que le code puisse littéralement prendre le contrôle du matériel de ta
TI-83 Premium CE
. Cela était possible officiellement depuis 1995 dans la gamme de calculatrices graphiques
Texas Instruments
grâce au support des programmes en langage machine, pouvant être créés à partir de code source écrit en langage
C
ou assembleur, et appelés plus généralement dans la communauté
"programmes assembleur"
.

Hélas, suite à l'irresponsabilité incommensurable d'un enseignant-vidéaste français,
Texas Instruments
a décidé de supprimer cette fonctionnalité historique, griffe qui avait fait le succès de ses produits, ce qui revient en gros à interdire tout développement non officiel de qualité professionnelle.

Les mises à jour et supérieures suppriment cette possibilité et t'interdiront de plus de revenir à toute version inférieure les autorisant. Et pour cette rentrée 2020, des modèles préchargés avec ces versions commencent à apparaître dans les stocks de boutiques. Tu ne peux donc bénéficier de ce qui suit que si tu as acheté une
TI-83 Premium CE
ou
TI-84 Plus CE
préchargée d'une version
5.4
ou inférieure, et si tu ne l'as pas mise à jour depuis.


En
novembre 2018
, te sortait son propre pack de 7 niveaux perso,
Holyxe World
. Une formidable aventure à sensations te conduisant des plus hautes tours aux profondeurs les plus abyssales.

Aujourd'hui , un passionné de
Oiram CE
extrêmement productif avec pas moins de
22
packs de niveaux perso publiés chez nous, résiste courageusement à
Texas Instruments
. se propose de revisiter
Holyxe World
, ou plus précisément un monde parallèle qu'il a nommé
Broken Holyxe World
. Au menu quelques petites altérations afin de te forcer à emprunter certains chemins plutôt que d'autres, ou encore à exploiter certains
glitchs
. ;)


Note bien que pour fonctionner correctement,
Oiram CE
a obligatoirement besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de les transférer. :)


Téléchargements
:

TI-z80 Mise à jour 5.5.2 TI-83 Premium CE + nouvelle appli Python

New postby critor » 13 Aug 2020, 17:22

Aujourd'hui,
Texas Instruments
nous sort pour ta
TI-83 Premium CE
sa mise à jour de rentrée 2020, la version
5.5.2
.

A noter que cette version ne concerne que les modèles français
TI-83 Premium CE
, pas les
TI-84 Plus CE
.

Elle fait donc suite à la mise à jour
5.5.1.0038
précédente
(
12 mai 2020
)
.

Plus précisément il s'agit ici d'une version
5.5.2.0044
compilée pour sa part le
30 juillet 2020
.

Seule nouveauté à notre connaissance, une toute nouvelle version de l'application
Python
.


Nous étions donc restés à la mise à jour précédente avec une application
Python
en version
5.5.0.0038
.

Cette version incluait à l'attention du coprocesseur
Atmel
un
firmware
TI-Python
en version
3.1.0.57
, comme on pouvait le découvrir en appelant sys.implementation.

Problème, cette application
Python
ne fonctionnait pas correctement.

Ce n'était pas systématique mais régulièrement, des caractères étaient perdus lors du retour d'informations du coprocesseur
Atmel
dédié au
Python
vers le processeur
eZ80
. :mj:

L'affichage de tes résultats pouvait donc apparaître erroné ou incohérent.

Et pareil lorsque tu rappelais une saisie précédente avec
. Tu pouvais n'en récupérer en apparence qu'une partie, et comme l'erreur ne concernait que l'affichage il ne fallait surtout pas tenter de corriger. :#non#:

Et bien voilà, la mise à jour
5.5.2
si effectuée via le fichier
bundle
combinant l'
OS
et les applis, mettra à son tour à jour ton application
Python
avec une version qui semble avoir corrigé le problème ! :bj:

Plus précisément, l'application
Python
passe en version
5.5.2.0044
et intègre un tout nouveau
firmware
TI-Python
3.1.0.58
.




Si tu disposes d'une ancienne
TI-83 Premium CE
(pas l'
Edition Python
donc)
, tu n'as aucune obligation et fort peu d'intérêt à mettre à jour et donc à renoncer à toute la bibliothèque de jeux et outils assembleur disponible chez nous ou ailleurs sur Internet. :#non#:
L'application
Python
ne fonctionnera de toutes façons pas sur ta calculatrice.
Quant aux applications apportant le reste des nouveautés
5.5
aucun besoin de mettre à jour le système, tu peux parfaitement les installer séparément à partir des liens ci-dessous.

Si tu disposes d'une
TI-83 Premium CE Edition Python
et souhaites bénéficier des dernières formidables nouveautés
Python
pas le choix, tu dois mettre à jour en version
5.5.1
ou supérieure.
Les applications
Python 5.5
refuseront en effet de fonctionner avec un système en version
5.4
ou inférieure.
Attention si tu fais le choix d'installer l'
OS 5.5.2
c'est définitif, ta calculatrice refusera tout retour à une version inférieure à
5.5.1
et il n'y a aucun menu pour réinitialiser cela. /!




Téléchargements
:


TI-z80 Mise à jour 5.6 pour TI-84 Plus CE avec appli Python

New postby critor » 13 Aug 2020, 16:45

WARNING !
If your
TI-84 Plus CE
is running
OS
version
5.4
or below, updating to version
5.5.5
or higher is going to permanently remove
ASM
support
.
Most games, and some programs, will not work anymore.
/!
The
Python
-related improvements
are only going to work on the
TI-84 Plus CE-T Python Edition
, not on the older
TI-84 Plus CE-T
or
TI-84 Plus CE
.
ATTENTION !
Si votre
TI-84 Plus CE
fait tourner un
OS
en version
5.4
ou inférieure, la mise à jour en version
5.5.5
ou supérieure va supprimer le support
ASM
et ce de façon permanente.
La plupart des jeux, et certains programmes, ne fonctionneront plus.
/!
Les nouveautés
Python
rajoutées en contrepartie ne fonctionneront que sur
TI-84 Plus CE Python Edition
, et pas sur les anciennes
TI-84 Plus CE-T
ou
TI-84 Plus CE
.





Aujourd'hui,
Texas Instruments
nous sort enfin pour ta
TI-84 Plus CE
sa mise à jour de rentrée 2020, la version
5.6
.

A noter que cette version ne concerne que les modèles européens
TI-84 Plus CE-T
et internationaux
TI-84 Plus CE
, pas le modèle français
TI-83 Premium CE
.

Elle fait donc suite selon le point de vue à la mise à jour
5.4.0.0034
précédente
(
31 mai 2019
)
, ou à la version
5.5.5.0011
préchargée dans les , grande nouveauté de cette rentrée.

Plus précisément il s'agit ici d'une version
5.6.0.0020
compilée pour sa part le
30 juillet 2020
.


L'
OS
5.5.5
préchargé dans les
TI-84 Plus CE-T Python Edition
n'incluait paradoxalement pas les fonctionnalités
Python
.

L'application
Python
préchargée bien trop petite pour ça n'était en fait qu'une coquille vide, affichant simplement d'aller télécharger l'application
Python
complète sur le site officiel.

Et bien voilà, la mise à jour
5.6
si effectuée via le fichier
bundle
combinant l'
OS
et les applis, rajoutera bien une application
Python
complète et parfaitement fonctionnelle, de quoi profiter directement de toutes les formidables nouvelles possibilités, du moins sur
TI-84 Plus CE-T Python Edition
! :bj:

Plus précisément, l'application
Python
est en version
5.5.2.0044
et intègre le
firmware
TI-Python
3.1.0.58
.


Autre nouveauté concernant le mode examen bleu, c'est-à-dire le mode examen international activable en allumant la machine avec les touches
enfoncées.

L'
OS 5.6
rajoute en effet une nouvelle restriction non activée par défaut, la possibilité d'interdire l'utilisation du solutionneur d'équations.


Cette restriction ne concerne pas le mode examen orange utilisé aux Pays-Bas, et activé à la différence en allumant la calculatrice avec les touches
+
enter
enfoncées.


Citons également d'autres nouveautés par rapport à la mise à jour
5.4
précédente, déjà traitées de notre côté dans le contexte de la mise à jour
5.5.1
pour le modèle français
TI-83 Premium CE
:
  • suppression de la gestion des programmes en langage machine dits assembleurs
  • mise à jour de l'application
    Periodic
    en version
    5.5
    avec actualisation de la base de données
  • mise à jour de l'application
    SciTools
    en version
    5.5
    avec actualisation de la base de données
  • mise à jour de l'application
    PlySmlt2
    en version
    5.5




Si tu disposes d'une ancienne
TI-84 Plus CE
ou
TI-84 Plus CE-T
(pas le
Python Edition
donc)
, tu n'as aucune obligation et fort peu d'intérêt à mettre à jour et donc à renoncer à toute la bibliothèque de jeux et outils assembleur disponible chez nous ou ailleurs sur Internet. :#non#:

L'application
Python
ne fonctionnera de toutes façons pas sur ta calculatrice.

Quant aux applications apportant le reste des nouveautés aucun besoin de mettre à jour le système, tu peux parfaitement les installer séparément à partir des liens ci-dessous.
Attention si tu fais le choix d'installer l'
OS 5.6
c'est définitif, ta calculatrice refusera tout retour à une version inférieure à
5.6
, et il n'y a aucun menu pour réinitialiser cela ni à ce jour aucune astuce pour contourner la chose. /!




Téléchargements
:


-
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.
864 utilisateurs:
>840 invités
>19 membres
>5 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)