π
<-
Chat plein-écran
[^]

NumWorks Coque NumWorks édition limitée Septembre 2021 à gagner

New postby critor » 27 Aug 2021, 21:10

13036Pour la rentrée
2019
,
NumWorks
te sortait une coque
collector
en édition limitée pour ta calculatrice, la
Macaremaths
, illustrée tout en humour et talent sur le thème des Mathématiques. :bj:

Dans le même genre
NumWorks
a renouvelé l'expérience en mieux avec une coque en édition limitée chaque mois depuis le rentrée
2020
. Tu as déjà eu nombre d'occasions d'habiller ta calculatrice de façon unique au monde :
1323013229
13573

Pour cette rentrée 2021
NumWorks
garde les bonnes habitudes, nouvelle chance pour toi de compléter ta collection avec la coque en édition limitée du mois de
Septembre 2021
.

Tu peux dès maintenant tenter de gagner la coque de rentrée sur les différents comptes sociaux du constructeur :

Pour participer et peut-être gagner, c'est très simple. Il te suffit d'ici le
30 Septembre 2021
de :
  1. suivre, aimer ou t'abonner au compte du constructeur
  2. taguer ou identifier un ami ou une amie

Tirage au sort d'un ou d'une gagnante sur chaque compte social le
30 Septembre
. N'hésite donc pas à participer sur les différents comptes sociaux, afin de maximiser tes chances. ;)

NumWorks Mise à jour application NumWorks Android/iOS v. 16.3.0

New postby critor » 27 Aug 2021, 08:51

14499La dernière mise à jour
16.3.0
d'
Epsilon
, le
firmware
officiel de la calculatrice
NumWorks
est sorti il y a quelques semaines. La page de mise à jour de la calculatrice se garde bien de t'en avertir, mais l'installation de cette version verrouille les calculatrices
NumWorks N0110
contre toute installation de
firmware
non officiel. :mj:

Un verrouillage à ce jour définitif sans aucun retour en arrière possible ; tu ne pourras plus installer le
firmware
Omega
(fini donc le calcul littéral et le tableau périodique des éléments)
, ni ses applications additionnelles compatibles
(fini donc le calcul formel avec
KhiCAS
, le tableur / feuille de calcul, ou encore les émulateurs
Nintendo Game Boy
et
Nintendo NES
)
. :'(

Pour cette rentrée 2021 la
NumWorks N0110
perd donc ce qu'elle avait de plus génial, de plus intéressant et de plus
cool
, et ce sans aucune baisse de prix en contrepartie. :mj:

10889La
NumWorks
ce n'est pas juste une calculatrice, c'est aussi une application pour
Android
et
iPhone / iPad
. :)

Oui chez
NumWorks
a priori tu pourrais croire n'avoir aucune obligation de dépenser pour l'achat d'une calculatrice. Tu peux apparemment retrouver la totalité de ses fonctionnalités sur ton
smartphone
ou ta tablette, et même l'utiliser aux évaluations si ton enseignant te le permet. Ce n'est que peut-être pour les évaluations communes ou examens blancs si l'ensemble des enseignants du lycée ne sont pas du même avis, et épreuves terminales écrites sous le cadre national n'autorisant comme outil numérique que la seule calculatrice en mode examen, que tu n'auras besoin d'acheter la calculatrice.
En réalité ce n'est pas tout à fait exact, et opter pour l'application
NumWorks
à la place de la calculatrice
NumWorks
est même un très mauvais choix. L'application
NumWorks
pour
Android
et
iPhone / iPad
est justement très lourdement bridée sur des capacités particulièrement embêtantes pour une utilisation scolaire, chose bien trop souvent passée sous silence :
  • Aucune persistance de la mémoire : tout ce que tu as saisi sera perdu à la moindre fermeture de l'application ! :mj:
  • Pas de gestion directe du clavier virtuel de ton
    smartphone
    ou tablette dans l'application
    NumWorks
    . Pour la saisie de tes scripts
    Python
    , tu auras le choix entre utiliser le clavier affiché de la calculatrice, et copier-coller le texte d'un script saisi/ouvert dans une autre application.
  • Aucune possibilité de sauvegarder le contenu mémoire si tu effectues des saisies ou modifications dans l'application
    NumWorks
    :mj:
  • Aucune gestion du tactile, tu ne peux pas cliquer sur l'écran, juste sur le clavier, et donc aucun raccourci possible pour éviter d'avoir à cliquer les diverses combinaisons de touches clavier

Après, tu restes parfaitement libre de tes choix, nous les respectons tant qu'ils sont pris en connaissance de cause.

Nous t'annonçons donc la mise à jour aujourd'hui en version
16.3.0
de l'application
NumWorks
pour
Android
et
iPhone / iPad
.

Tu peux donc dès maintenant bénéficier sur ton
smartphone
ou ta tablette des dernières nouveautés apportées au logiciel
NumWorks
.

Liens
:

Référence
:
https://www.numworks.com/fr/blog/logiciel-securise/

TI-Nspire CCC 2021 épisode 9: TI-Nspire CX rév≤N (batterie avec câble)

New postby critor » 26 Aug 2021, 19:20

Combien Consomme ma Calculatrice 2021

Épisode 9 - TI-Nspire CX révision ≤N (batterie avec câble)

index des épisodes

5409Nous sommes en plein , événement au cours duquel nous te publions et alimentons la base de données intégrale de nos classements de rentrée
QCC
organisés depuis la rentrée 2015.

Nous t'avons également lancé un événement dans l'événement, le
CCC 2021
, pour
Combien Consomme ma Calculatrice
.

1452314518Nous nous étions d'abord occupés de mesurer l'intensité tirée par les modèles à piles
AAA
. Pour cela nous avions ouvert le circuit en utilisant une fausse pile, bricolée à cette fin.

Puis nous étions passés aux modèles à batterie. Nous ne pouvions bien évidemment pas utiliser le même protocole. Nous avions retenu un testeur
USB
. Afin d'espérer éliminer la consommation due au circuit de recharge de la batterie, nous avions réalisé les mesures avec la batterie retirée, la calculatrice étant donc intégralement alimentée via son port
USB
.

Pour des intensités très faibles, calculatrices éteintes, vu les mesures obtenues nous doutions de la précision et donc fiabilité de ce testeur
USB
.
On pouvait toutefois supposer que les mesures avec calculatrice allumée était bien plus correctes, et probablement comparables d'un modèle à un autre.

Restait toutefois une inconnue. Même avec batterie déconnectée, le circuit de recharge ne viendrait-il pas perturber les mesures en question ?

1452514524Aujourd'hui donc, nous reprenons les mesures concernant les
TI-Nspire CX
de révision matérielle
N
ou inférieure
(produites jusqu'en
octobre 2015
)
, c'est-à-dire celles utilisant une batterie avec câble.

Remercions qui a grandement contribué à la faisabilité de ce test. Il nous a en effet fort gracieusement envoyé une de ces batteries jamais utilisée et donc entièrement neuve, l'idéal pour le test. :favorite:

Nous nous munissons d'éléments permettant de lui adjoindre une rallonge. Il suffit pour cela de chercher de la connectique pour batteries
LiPo
à 4 câbles.

145291452814527
Rajoutons sur la voie d'alimentation de la rallonge en question un interrupteur inverseur :
  • position
    I
    pour une alimentation normale de la calculatrice
  • position
    II
    pour la connexion d'un ampèremètre sur les bornes externes

14531Et voici donc le protocole de mesure final.

Le même style de protocole serait réalisable pour les
NumWorks
, mais nous ne disposons pas encore des références de connectique batterie les concernant.

Pour les
HP Prime
et
TI-Nspire CX
plus récentes utilisant une batterie format
smartphone
Samsung
, impossible de procéder de cette façon puisqu'elles sont dépourvues de câble. :#non#:
Il nous faudra trouver autre chose...

1451414513Les mesures sont effectuées à l'aide d'une
TI-Nspire CX II
. Nous utiliserons un capteur d'intensité
Vernier
, muni d'une prise
BT-A
(le standard historique de téléphonie analogique chez
British Telecom
)
. Nous le relions donc à la
TI-Nspire CX II
à l'aide de l'interface
Vernier EasyLink
.

Nous configurons la
TI-Nspire CX II
pour effectuer :
  • 50
    mesures par seconde
  • pendant une durée de
    29
    secondes

Les mesures sont effectuées avec la batterie chargée à
100%


Nous allons effectuer les mesures sous différentes conditions :
  • Calculatrice éteinte
    (hors mode examen + en mode examen)
  • Calculatrice allumée mais inoccupée
    (hors mode examen + en mode examen)
  • Calculatrice en train d'effectuer un calcul suffisamment long
    (hors mode examen + en mode examen)

    Nous choisissons en mode degrés :
    $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

De plus, nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :
  • maximal
  • minimal

Enfin, les mesures seront effectuées sur 4 calculatrices différentes, et nous retiendrons la moyenne :
  • TI-Nspire CX
    en révision matérielle
    C
  • TI-Nspire CX CAS
    en révision matérielle
    C
  • TI-Nspire CX CAS
    en révision matérielle
    D
  • TI-Nspire CX CAS
    en révision matérielle
    J

Bien meilleure précision ici
(ou absence d'élément perturbateur)
, les mesures relevées sont comme tu peux le constater ci-contre extrêmement proches d'une calculatrice à une autre, confirmant la pertinence du regroupement de toutes les machines de révision
N
ou inférieure.

Éteintes, ces
TI-Nspire CX
tirent donc en moyenne
0,726 mA
.

Une fois le mode examen activé, la diode examen s'active toutes les 2 secondes avec un double
flash
, ce qui génère des pics de consommation comme illustré sur le diagramme ci-contre. Cela fait monter l'intensité moyenne mesurée à
1,107 mA
.

Voici le reste des mesures :
TI-Nspire CX rév. ≤N
hors
mode examen
en
mode examen
éclairage
écran
éteinte
0,829 mA
1,093 mA
(+31,75%)
inoccupée
24,468 mA
73,163 mA
24,851 mA
(+1,56%)

73,567 mA
(+0,55%)
minimal
maximal
calcul
39,873 mA
89,189 mA
40,232 mA
(+0,90%)

89,671 mA
(+0,54%)
minimal
maximal

Comme sur certains modèles à écran couleur, nous n'avons pas moyen de rerégler la luminosité par défaut, nous retenons pour les comparaisons les mesures effectuées sous la luminosité maximale.

Tableau comparatif :
Accès
QCC 2021 Universel

TI-Nspire QCC 2021 Universel épisode 10: Python turtle + compatibilité

New postby critor » 25 Aug 2021, 20:15

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 10 - Python turtle + compatibilité

5409Pour fêter les 10 ans de
TI-Planet
en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée
QCC
organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
  • toutes les calculatrices graphiques
    Texas Instruments
    (depuis la première
    TI-81
    de 1990)
  • les calculatrices graphiques
    Casio
    de la génération
    Icon Menu Power Graphic
    (depuis 1996)
Ce qui donne pas moins de
163
modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic ! :D

14526Aujourd'hui restons sur le
Python
et parlons
turtle
. Il y a justement du nouveau à ce sujet, puisque
Texas Instruments
vient tout juste de sortir un module
turtle
additionnel pour ses
TI-Nspire CX II
.

Mais qu'est-ce que c'est que
turtle
? Les interpréteurs
Python
sur nos calculatrices peuvent offrir usuellement jusqu'à 3 types de modules de tracé :
  • tracé par pixels, habituellement propriétaire au constructeur
  • tracé dans un repère, plus ou moins proche du standard
    matplotlib.pyplot
  • et tracé relatif à la tortue, plus ou moins proche du standard
    turtle
    , le plus proche de ce qui a été pratiqué au collège avec le langage
    Scratch

Nous allons profiter de l'occasion pour faire d'une pierre deux coup. Nous allons à la fois découvrir ensemble le nouveau
turtle
des
TI-Nspire CX II
, et directement le comparer à ce qui existe déjà chez la concurrence, à savoir :
  • turtle
    pour
    TI-Nspire CX II
  • turtle
    sur
    Casio Graph 35+E II
    et
    Graph 90+E
  • turtle
    sur
    NumWorks
  • turtle
    via
    KhiCAS
    sur
    NumWorks
    et
    TI-Nspire CX
  • ce_turtl
    sur
    TI-83 Premium CE Edition Python
    ,
    TI-84 Plus CE-T Python Edition
    et
    TI-84 Plus CE Python

Nous allons donc exécuter quelques scripts
turtle
et comparer leurs affichages à ce que donne le
turtle Python
standard sur ordinateur, et donc la plus ou moins grande facilité que tu auras à exécuter des scripts
Python turtle
conçus pour d'autres plateformes.
ce_turtl
était particulièrement mauvais sur ce dernier point ; nous allons donc voir si
Texas Instruments
a apporté davantage de soin à son module
turtle
pour
TI-Nspire CX II
.

Commençons déjà par détecter quelques problèmes bloquants avant l'exécution, et peut-être même les corriger. Voici notre tout nouveau
Turtle Doctor
: ;)
Code: Select all
_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
  _turtle_error(0)
except ImportError:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolorlist(c): return c
  def _fixcolorval(c): return c
  def _fixcolorstring(c): return c
  def _fixcolor(c): return turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(c)))
  turtle._fixcolorlist = _fixcolorlist
  turtle._fixcolorval = _fixcolorval
  turtle._fixcolorstring = _fixcolorstring
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test/fix color() + pencolor()
if not "pencolor" in dir(turtle):
  _turtle_error(1)
  if _fix_turtle: turtle.pencolor = turtle.color
if not "color" in dir(turtle):
  _turtle_error(2)
  if _fix_turtle: turtle.color = turtle.pencolor

# test color argument types
_color_types = 0
try:
  turtle.pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  turtle.pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  turtle.pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: pass
try:
  turtle.pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(6)
_fix_color = not _color_types & 1 << 0 or not _color_types & 1 << 1 or not "colormode" in dir(turtle)

# fix list/tuple color argument
if _fix_turtle:
  if not _color_types & 1 << 0 and _color_types & 1 << 1:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 1 << 1 and _color_types & 1 << 0:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist

# fix color() + pencolor()
if _fix_turtle and _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    if _color_types & 1 << 0 or _color_types & 1 << 1:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(argv[0])
        turtle._pencolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor

# test/fix colormode()
_color_mode = 0
if not "colormode" in dir(turtle):
  _turtle_error(3)
  # test color mode
  try:
    turtle.pencolor([255, 0, 0])
    _color_mode = 255
  except: _color_mode = 1.0
  if _fix_turtle:
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      def _fixcolorval(c): return int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      def _fixcolorval(c):
        return turtle._color_mode == 255 and type(c) in (list, tuple) and [int(c[k] / 255) for k in range(3)] or c
    turtle._fixcolorval = _fixcolorval

# test/fix color strings
_colors_fix={"black":(0,0,0),"blue":(0,0,1),"green":(0,1,0),"red":(1,0,0),"cyan":(0,1,1),"yellow":(1,1,0),"magenta":(1,0,1),"white":(1,1,1),"orange":(1,0.65,0),"purple":(0.66,0,0.66),"brown":(0.75,0.25,0.25),"pink":(1,0.75,0.8),"grey":(0.66,0.66,0.66)}
for c in list(_colors_fix.keys()):
  try:
    turtle.pencolor(c)
    _colors_fix.pop(c)
  except: pass
turtle.pencolor((0, 0, 0))
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(7)
  if _fix_turtle:
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

# test/fix circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(8)
  if _fix_turtle:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

if not "write" in dir(turtle):
  _turtle_error(9)
  if _fix_turtle:
    def _write(s): pass
    turtle.write = _write

if not "pensize" in dir(turtle):
  _turtle_error(10)
  if _fix_turtle:
    def _pensize(s): pass
    turtle.pensize = _pensize

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode(): " + str(_color_mode),
    "No color as list",
    "No color as tuple",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "No write()",
    "No pensize()",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 7:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

Le but de
Turtle Doctor
et donc d'anticiper les erreurs, afin que les scripts qui vont suivre puissent bien afficher quelque chose d'utile.

Par exemple,
Turtle Doctor
ne détecte a priori strictement aucun problème bloquant sur la
NumWorks
:bj:

Aucun problème non plus avec
KhiCAS
pour
NumWorks
et
TI-Nspire CX
! :bj:

Sur
Casio Graph 35+E II
et
Graph 90+E
, quelques détails :
  • absence de la méthode
    .color()
  • absence de la méthode
    .colormode()
Mais ici,
Turtle Doctor
détecte que le module
turtle
est modifiable : on peut le
patcher
à chaud
(à chaque exécution)
afin de corriger. :D

Le but des corrections n'est pour le moment pas d'obtenir quelque chose d'identique au standard, mais juste de permettre l'exécution des scripts qui vont suivre :
  • Nous choisissons de créer une méthode
    .color()
    synonyme de
    .pencolor()
  • Et pour
    .colormode()
    , outre la création de la méthode, il nous faut détecter le format de coordonnées de couleurs attendu par le module, afin de convertir le cas échéant. La méthode
    .colormode()
    lorsque présente permet de basculer entre les 2 systèmes de coordonnées suivants :
    • mode
      255
      : couleurs
      RGB
      avec chaque composante prenant une valeur entière de
      0
      à
      255
    • mode
      1.0
      : couleurs
      RGB
      avec chaque composante prenant une valeur flottante de
      0
      à
      1
    Le module
    turtle
    travaille en fait en format
    1.0
    , mode qu'il est donc impossible de modifier ici.

Voici maintenant donc enfin
turtle
pour
TI-Nspire CX II
.

Une fois installé correctement dans le dossier
/PyLib/
comme expliqué, les fonctions offertes par
turtle
sont alors rajoutées au menu.

Attention toutefois, comme tout module présent dans le dossier
/PyLib/
,
turtle
ne sera pas disponible en mode examen. :#non#:

Le module s'importe de la façon suivante, qui est bien une des façons standard :
Code: Select all
from turtle import Turtle
turtle = Turtle()


Si jusqu'à présent les quelques écarts avec le standard pouvaient être qualifiés de quelques détails de cas particuliers, ici cela commence à faire beaucoup. Pas moins de 4 problèmes sont détectés dont un majeur :
  • absence de la méthode
    .colormode()
    , avec un fonctionnement bloqué en mode
    255
  • absence de gestion du 2ème argument de la méthode
    .circle()
    pour tracer un arc de cercle
  • et pire, pour les paramètres de couleur :
    • refus des paramètres de type liste, n'accepte que des tuples -
      est-ce un bug ?...
      :(
    • accepte les paramètres de type chaîne de caractères, mais ignore plusieurs codes de couleur usuels :
      "pink"
      ,
      "grey"
      ,
      "brown"
      ,
      "purple"
Heureusement ici, le module
turtle
importé est modifiable à chaud et peut donc être librement modifié et donc corrigé. En approfondissant la chose, la méthode
Turtle Doctor
devrait même permettre de pouvoir atteindre une conformité quasi parfaite au standard.

Et enfin nous avons le
ce_turtl
pour les éditions
Python
des
TI-83 Premium CE
et
TI-84 Plus CE
. Comme annoncé hélas, c'est une véritable catastrophe niveau conformité au standard. Pas moins de 8 erreurs sont anticipées :
  • déjà, de par son nom il ne s'importe pas de façon standard, c'est-à-dire qu'aucune des 3 méthode suivantes ne fonctionne :
    import turtle, from turtle import *, ou encore
    Code: Select all
    from turtle import Turtle
    turtle = Turtle()
  • absence de la méthode
    .pencolor()
    , qui est remplacée ici par
    .color()
  • absence de la méthode
    .colormode()
    , avec un fonctionnement bloqué en mode
    255
  • absence de la méthode
    .write()
    pour écrire du texte
  • absence de gestion du 2ème argument de la méthode
    .circle()
    pour tracer un arc de cercle
  • et pire, pour les paramètres de couleur, refus de toute les formes standard : aussi bien liste que tuple ou chaîne de caractère. La méthode
    color()
    attend non pas 1 mais 3 arguments, soit un argument par composante. :mj:
Le module
turtle
importé est certes modifiable à chaud et la méthode
Turtle Doctor
va fonctionner pour débloquer l'exécution. Toutefois pour une conformité au standard il manquerait encore beaucoup de code, et malheureusement comme nous avons déjà vu nous sommes extrêmement à l'étroit niveau mémoire de tas
(heap)
Python
sur ces calculatrices. Nous sommes déjà à peine à quelques lignes de l'erreur de mémoire, aller plus loin dans cette voie n'est pas envisageable sur ces modèles. :'(

Pour comparer, il y a malgré tout moyen d'avoir du code d'importation fonctionnant à la fois sur l'ensemble de ces plateformes et sur ordinateur. Par exemple :
Code: Select all
try: # TI-83PCE/84+CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError:
  import turtle # multiplateformes
  if not "forward" in dir(turtle): # TI-Nspire CX II
    turtle = turtle.Turtle()

1107511073Voilà, c'est parti pour les tests de conformité du module
turtle
standard, ainsi que la compatibilité entre différentes calculatrices graphiques.

Nous allons pour cela prendre plusieurs exemples et lancerons le même code sur différents modèles.

On commence par une petite rosace ; tout possesseur de
Graph 35+E II
sait que Casio adore ça : ;)
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

turtle.speed(0)
turtle.pensize(1)
for i in range(12):
  turtle.left(30)
  for i in range(8):
    turtle.forward(30)
    turtle.left(45)

try: turtle.show() #TI-83 Premium CE
except: pass

Petit léger détail, le
turtle.pensize(1)
n'est respecté ni par
KhiCAS
ni par
ce_turtl
.

Ceci mis à part, le code passe ici sans problème. :)

Poursuivons avec la fractale de Koch :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def koch(n, l):
  if n==0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

turtle.speed(0)
turtle.pensize(1)
turtle.pencolor("blue")
turtle.penup()
turtle.goto(-180, -50)
turtle.pendown()
koch(4, 360)

try: turtle.show() #TI-83 Premium CE
except: pass

Pas de nouveau problème ici. :)

Passons maintenant aux flocons de Koch :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

turtle.speed(0)
l=80
turtle.pensize(1)
turtle.penup()
turtle.goto(105,3)
turtle.left(120)
turtle.pendown()
flock(3, l)
turtle.left(120)

turtle.penup()
turtle.goto(105,-10)
turtle.right(60)
turtle.pendown()
turtle.pencolor("orange")
flock(4, l)
turtle.right(60)

turtle.pensize(2)
turtle.penup()
turtle.goto(5,45)
turtle.right(60)
turtle.pendown()
turtle.pencolor("blue")
flock(2, l)
turtle.right(60)

turtle.penup()
turtle.goto(-100,17)
turtle.left(120)
turtle.pendown()
turtle.pencolor("red")
flock(0, l)
turtle.left(120)

turtle.pensize(3)
turtle.penup()
turtle.goto(-100,-5)
turtle.right(60)
turtle.pendown()
turtle.pencolor("green")
flock(1, l)
turtle.right(60)

turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

Pour ce que l'on obtient pas de problème de tracé avec le module
turtle
de
KhiCAS
, le problème vient d'autre chose. Ce module
turtle
a l'air d'être extrêmement gourmand, arrivant à déclencher une erreur de mémoire en cours d'exécution alors que d'autres modèles avec un
heap
Python
absolument ridicule en comparaison s'en sortent parfaitement.

On comprend mieux ici le problème du
.pensize()
sur
ce_turtl
et
KhiCAS
. Malgré les réglages différents tous les flocons sont ici trop épais d'1 pixel, il y a visiblement un décalage.
Mais notons justement par rapport à
ce_turtl
, que notre script
Turtle Doctor
a visiblement correctement injecté l'interception des paramètres de couleurs passés sous la forme de chaînes de caractères.

Nous arrivons maintenant à un soleil :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  for i in range(1, 5):
    turtle.forward(60)
    turtle.right(90)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

Notons que
Turtle Doctor
a réussi à parfaitement corriger les paramètres de couleurs sur
ce_turtl
, tuples et listes étant maintenant utilisables ! :bj:

Poursuivons avec une coquille d'escargot :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  turtle.circle(50 - i)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

ce_turtl
nous fait ici une véritable catastrophe. Le problème vient de la méthode
.circle()
qui ne respecte pas du tout le standard. Au lieu de tracer un cercle qui passe par la position de la tortue, elle trace un cercle qui prend pour centre la position de la tortue. :mj:

Passons maintenant aux triangles de Sierpiński :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def sierp(n, l):
  if n == 0:
    for i in range (0, 3):
      turtle.forward(l)
      turtle.left(120)
  if n > 0:
    sierp(n - 1, l / 2)
    turtle.forward(l / 2)
    sierp(n - 1, l / 2)
    turtle.backward(l / 2)
    turtle.left(60)
    turtle.forward(l / 2)
    turtle.right(60)
    sierp(n - 1, l / 2)
    turtle.left(60)
    turtle.backward(l / 2)
    turtle.right(60)

turtle.speed(0)
turtle.pensize(1)
turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
turtle.pencolor("red")
sierp(6, 217)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Ici encore, après avoir commencé un tracé parfait,
KhiCAS
se met à manquer de mémoire.

La
Casio Graph 90+E
s'en sort fort honorablement jusqu'à présent, non ? Dédions-lui un tableau :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

turtle.speed(0)
turtle.forward(40)
turtle.backward(100)
turtle.left(90)
turtle.forward(30)
turtle.right(60)
turtle.forward(60)
turtle.right(30)
turtle.forward(30)
turtle.penup()
turtle.forward(18)
turtle.right(90)
turtle.forward(60)
turtle.pendown()
turtle.right(30)
turtle.backward(30)
turtle.right(60)
turtle.forward(60)
turtle.pencolor("red")
turtle.penup()
turtle.goto(80,40)
turtle.right(140)
turtle.pendown()
turtle.circle(30)
turtle.penup()
turtle.goto(105,50)
turtle.pencolor("green")
turtle.pendown()
turtle.circle(-50)
turtle.penup()
turtle.pencolor("red")
turtle.right(21)
turtle.goto(60,20)
turtle.pendown()
turtle.circle(40,60)
turtle.penup()
turtle.pencolor("blue")
turtle.goto(-50,15)
turtle.setheading(0)
turtle.pendown()
turtle.write("CASIO")

try: turtle.show() #TI-83 Premium CE
except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Rapidement, très léger détail sur les
Casio Graph 35+E II
et
Graph 90+E
. La méthode
.write()
prend les coordonnées indiquées comme coin supérieur gauche du texte affiché, alors que le standard est de les prendre comme coin inférieur gauche.

Pour les modules qui ne gèrent pas l'appel .circle(rayon, angle) les arcs de cercles sont ici remplacés par des cercles, ce qui naturellement perturbe le reste du tracé.

Le cas
KhiCAS
est toutefois plus surprenant, cet appel étant bien géré... :#roll#:

Le nouveau
turtle
TI-Nspire CX II
est une superbe réalisation. On apprécie particulièrement la grille et le repère entièrement configurables, une véritable valeur ajoutée ! :bj:

Sur la conformité au standard
turtle
ce n'est certes pas le meilleur, même si cela reste honorable. Il y a bien pire et plus grave que cela.
Texas Instruments
a déjà fait un fort bel effort relativement à la catastrophe qu'était
ce_turtl
. :)

Nous ignorons si
Texas Instruments
poursuivra ses efforts, mais à défaut nous avons quand même une excellente nouvelle. Bien que l'on n'ait pas accès au code source du module
turtle
TI-Nspire CX II
celui-ci a le gros avantage de nous présenter des éléments modifiables à chaud. Comme de plus nous bénéficions ici d'un
heap
Python
extrêmement généreux, pas moins de
2 Mo
soit l'un des plus larges tous modèles concurrents confondus, une conformité parfaite au standard est bel et bien envisageable, pourvu que quelqu'un se donne le temps de creuser la question. :bj:

En attendant donc mieux, les différentes solutions
Python turtle
disposent désormais dans nos tableaux d'un indice de compatibilité / conformité au standard, basé sur les tests précédents :

TI-z80 Mario Kart CE, enfin compatible TI-83 Premium CE 5.6.1

New postby critor » 23 Aug 2021, 14:52

12303La
TI-83 Premium CE
dispose chez nous d'une formidable bibliothèque de jeux. Parmi les incontournables, on peut citer entre autres :
Et si nous faisions une partie de
Mario Kart
?

Problème,
TI-Boy CE
n'émule que la console de jeux
Game Boy
monochrome de 1989. Les jeux sortis pour son évolution
Game Boy Color
à compter de 1998, ne sont donc pas compatibles.

Et pour
Mario Kart
c'est encore pire, puisque sur consoles portables il a fallu attendre la
Game Boy Advance
de 2001.

13747Dans une actualité précédente, nous t'annoncions que relevait malgré tout le défi de faire tourner
Mario Kart
sur ta calculatrice.

Ne pouvant passer par l'émulateur
TI-Boy CE
ni espérer un émulateur de
Game Boy Advance
pour le moment, l'idée était donc de reconstruire intégralement le jeu
Mario Kart
à partir de zéro ! :o

Son jeu
Mario Kart CE
est compatible avec les
TI-83 Premium CE
(ainsi que leurs équivalents
TI-84 Plus CE
hors de France)
.
Attention, pas de compatibilité avec la
TI-82 Advanced Edition Python
, ne confonds pas si tu comptes t'équiper prochainement ! :#non#:

Tu affrontes donc 5 IAs
(Intelligence Artificielle)
pilotant les voitures concurrentes, et les touches sont les suivantes :
  • entrer
    pour choisir entre les 8 personnages jouables issus de l'univers de
    Super Mario
  • alpha
    pour lancer des carapaces sur tes adversaires
  • pour freiner et reculer
  • pour tourner
  • 2nde
    pour accélérer
Des obstacles sont présents ainsi que des blocs bonus, mais pour ces derniers non encore fonctionnels.

Le circuit pour le moment unique adapte le 1er circuit de la
Mushroom Cup
du jeu pour
Nintendo SuperNES
, tu as ci-contre de quoi comparer.

Pour le moment le jeu n'a pas de fin.

Problème,
Mario Kart CE
n'était pas compatible avec la dernière mise à jour
5.6.1
des
TI-83 Premium CE
et
TI-84 Plus CE
.

Et sur ces modèles, une fois une mise à jour effectuée, il ne t'est plus possible de revenir à une ancienne version. :#non#:

Et bien surprise. Pour t'offrir une rentrée 2021 des plus agréables, t'offre enfin aujourd'hui une mise à jour
Mario Kart CE
compatible avec la dernière version
5.6.1
! :D

Attention,
Mario Kart CE
rentre dans la catégorie des programmes en langage machine dits
ASM
.

Or, suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations aveugles dans le contexte de la réforme du lycée,
Texas Instruments
a réagi en supprimant la gestion de tels programmes depuis la mise à jour
5.5.1
.

Si tu es sur une des versions ainsi bridées, tu peux quand même jouer sans trop d'efforts. Il te faut :
  1. installer
    arTIfiCE
    pour remettre la possibilité de lancer des programmes
    ASM
  2. ensuite de préférence installer
    Cesium
    pour pouvoir lancer les programmes
    ASM
    plus facilement, ou même
    AsmHook
    pour pouvoir les lancer comme avant

Téléchargements
:


Source
:
https://www.cemetech.net/forum/viewtopic.php?t=9757

Crédits images
:


TI-z80 Stage pré-rentrée 2021 Python 83 Premium CE : liste sessions

New postby critor » 23 Aug 2021, 12:46

Enseignant de Mathématiques ou Sciences en lycée ? Les
vendredi 27
,
lundi 30
et
mardi 31 août 2021
,
Texas Instruments
t'invite à un stage de pré-rentrée en ligne entièrement gratuit. :D

Sur ces 3 jours, un choix formidable de pas moins de 12 sessions d'1 heure te sera proposé.

Note bien que tu jouis d'une totale liberté ; tu n'as aucune obligation de participer à l'intégralité des 12 sessions, tu pourras t'inscrire pour les sessions de ton choix, même 1 seule si tu veux ! :bj:

Le stage est dédié à la programmation
Python
sur
TI-83 Premium CE
, de quoi bien se mettre en jambe pour la rentrée. ;)

13073967713087Les sessions seront animées par nul autre que
Jérôme Lenoir
, enseignant bivalent de Mathématiques et Physique-Chimie en lycée professionnel.

Un fin connaisseur de la programmation
Python
sur
TI-83 Premium CE
, auteur de divers ouvrages d'activités à ce sujet, et qui saura sans nul doute répondre à tes diverses interrogations ! :bj:

Afin de te proposer une sélection de sessions la plus conforme possible à tes attentes,
Texas Instruments
t'avait proposé quelque chose d'inédit. Depuis début Juillet, tu avais la possibilité de voter pour les sessions que tu préférais parmi une 20aine de propositions.

Aujourd'hui,
Texas Instruments
nous révèle donc le calendrier des 12 sessions retenues pour cette rentrée 2021 :
  • Vendredi 27 août :

    • 8h00 :
      Présentation de la TI-83 Premium CE Édition Python et de l'écosystème, mise à jour, premiers pas avec l'application Python
    • 9h30 :
      Découverte des bibliothèques Python : raccourcis & utilisation
    • 13h00 :
      Utiliser les représentations graphiques via Python en mathématiques
    • 14h30 :
      Premiers exemples de scripts Python en mathématiques
  • Lundi 30 août :

    • 8h00 :
      Premiers exemples de scripts Python en physique-chimie
    • 9h30 :
      Les cartes à microcontrôleur (1/2) : fonctionnement du TI-Innovator Hub couplé à la TI-83 Premium CE
    • 13h00 :
      Les cartes à microcontrôleur (2/2) : fonctionnement de la BBC Micro bit couplé à la TI-83 Premium CE
    • 14h30 :
      Créer un scénario pédagogique de mathématiques incluant la programmation en Python dans la voie générale & technologique
  • Mardi 31 août :

    • 8h00 :
      Créer un scénario pédagogique de mathématiques incluant la programmation en Python dans la voie professionnelle
    • 9h30 :
      Hybrider une séquence intégrant algorithmique et programmation
    • 13h00 :
      Différencier son enseignement à l'aide de l'algorithmique et de la programmation
    • 14h30 :
      Échange avec les délégués pédagogiques TI
Les inscriptions sont dès maintenant ouvertes sur le lien ci-dessous.

Lien
:
inscription

-
Search
-
Social
-
Featured topics
Concours de rentrée 2021 - La Geste d'Alrys
Concours de rentrée 2021 - Synchro-donjon !
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Remplace ton ancienne fx-92 Collège ou Graph 35 par la nouvelle Graph 35+E II programmable en Python ! Pour tout achat d'une nouvelle Graph 35 d'ici le 30 septembre 2021, Casio te rembourse 10€. En cas de retour de ta fx-92 Collège c'est 18€, et même ou 23€ si tu retournes ton ancienne Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du cœur.
Remplace ton ancienne fx-92 Collège ou Graph 35 par la Graph 90+E couleur. Pour tout achat, Casio te rembourse 10€ en cas de retour de ta fx-92 Collège, ou 15€ en cas de retour de ta Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du coeur.
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 35 d'ici le 30 Septembre 2021
Reprise de ton ancienne fx-92 Collège à 5€ ou Graph 35 à 10€. Même non fonctionnelle ou ancien modèle. Etiquette de retour fournie, pas de frais de port à payer. En partenariat avec les Restos du coeur.
25€ remboursés par Casio sur l'achat de ta calculatrice fx-CP400 d'ici le 31 Octobre 2021
3€ remboursés par Casio sur l'achat de ta calculatrice fx-92 Collège d'ici le 30 Septembre 2021
Casio Graph 90+E ou Graph 35+E II avec couvercle personnalisé à gagner sur simple participation aux formations Casio de Septembre 2021.
Disque dur externe + écouteurs bluetooth + 2 superbes coques personnalisées pour Graph 90+E ou Graph 35+E II à gagner en répondant d'ici le 24 Septembre 2021 à la question : "Quelle est l'unité de tension électrique ?"
Coque NumWorks édition limitée Septembre 2021 à gagner.
123456789101112
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
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.
669 utilisateurs:
>640 invités
>23 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)