π
<-
Chat plein-écran
[^]

News 2020
August (6)
July (14)
June (11)
May (8)
April (19)
March (4)

News 2019
August (2)
July (3)
June (4)
May (8)
April (3)
March (5)

News 2018
August (7)
June (11)
May (5)
April (13)
March (12)

News 2017
August (5)
July (6)
June (3)
May (3)
April (20)
March (11)
January (10)

News 2016
August (5)
July (5)
June (4)
May (3)
April (6)
March (2)

News 2015
August (6)
July (6)
June (5)
May (4)
April (12)
March (8)

News 2014
August (6)
July (7)
June (3)
May (1)
April (2)
March (6)

News 2013
August (6)
July (14)
June (1)
May (5)
April (1)
March (1)

News 2012
August (3)
July (3)
June (3)
April (2)
March (3)

News 2011

Maj clé USB émulation Graph 90+E 3.50 et Graph 35+E II 3.40

New postby critor » 26 Oct 2020, 20:12

Casio
vient tout juste de nous sortir des mises à jour
3.40
et
3.50
absolument superbes pour ses
Graph 35+E II
et
Graph 90+E
. Au menu des possibilités
Python
étendues avec :
  • pour le module de tracé par pixels
    casioplot
    l'indexation dans le catalogue de la fonction de nettoyage
    clear_screen()
  • concernant le module de tracés relatifs
    turtle
    :
    • il devient intégré au système, donc indexé au catalogue et disponible en mode examen
    • la fonction
      pensize()
      est maintenant fonctionnelle
  • quant au module de tracé par coordonnées
    matplotl
    :
    • il est renommé
      matplotlib.pyplot
      pour une meilleure compatibilité avec les scripts provenant d'autres plateformes
    • il devient lui aussi intégré au système, donc indexé au catalogue et disponible en mode examen
    • la fonction
      bloxplot()
      gère désormais le tracé à la française des diagrammes en boîte via un paramètre nommé optionnel
    • nouvelle fonction
      hist()
      pour le tracé d'histogrammes, gérant également le tracé à la française via un paramètre nommé optionnel
    • correction de la fonction
      arrow()
      qui dans certains cas tracés les pointes de flèches de vecteurs à l'envers, et en prime remplit désormais ces dernières sur
      Graph 90+E


Mais par contre, jusqu'à présent la mise à jour ne concernait que les calculatrices, pas les émulateurs pour ordinateur.

Tu pouvais certes leur rajouter manuellement les nouvelles versions
turtle.py
et
matplotl.py
que nous t'avions diffusé à l'occasion, mais cela ne te rajoutait pas l'intégralité des nouveautés :
  • aucun nouvelle entrée indexée au catalogue via cette méthode :#non#:
  • et tu ne bénéficiais pas non plus du renommage de
    matplotl
    en
    matplotlib.pyplot
    de cette façon :#non#:

13023Et bien ce fut rapide,
Casio
te diffuse déjà des mises à jour pour ses émulateurs sur clés
USB
d'émulation, bien évidemment compatibles avec les deux versions en circulation à ce jour.

Il te suffira tout simplement de placer les fichiers
.zip
disponibles ci-dessous à la racine de ta clé
USB
, d'en lancer l'extraction, et éventuellement de confirmer l'écrasement des anciens fichiers. Si tu sais ce que tu fais, tu peux également copier-coller le nouveau fichier
.exe
directement au bon endroit.

Tu pourras ainsi bénéficier de l'intégralité des nouvelles fonctionnalités en classe dès la rentrée ! :bj:
Merci
Casio
. ;)

Téléchargements
:


Lien
:
tutoriel de mise à jour calculatrices + clé USB

Maj Graph 90/35+E II 3.50/3.40: Python turtle + matplotlib

New postby critor » 19 Oct 2020, 11:49

Juste à temps pour le lancement des journées
APMEP
ce week-end,
Casio
nous a offert une mise à jour majeure de l'ensemble de sa gamme graphique non formelle ! :bj:

Pour une fois, les mises à jour ciblent aussi bien les dernières générations monochromes et couleurs que les générations les ayant précédées :
  • 3.50
    pour
    Graph 90+E
    et
    fx-CG50
  • 3.40
    pour la génération monochrome
    USB Power Graphic 3
    (
    Graph 35+E II
    en France,
    fx-9750GIII
    et
    fx-9860GIII
    dans d'autres pays)
  • 3.12
    pour
    fx-CG10
    et
    fx-CG20
  • 2.11
    pour les anciennes générations monochromes
    USB Power Graphic 1
    et
    USB Power Graphic 2

Des nouveautés d'importance sont donc ici transversales, d'où notre tentative de les traiter dans un unique article.

Avant cela, nous avons une petite chose à mettre au point. Les logiciels d'installation de mises à jour
Casio
contiennent usuellement plusieurs images système installables sur différentes variantes d'un modèle selon les pays. Avant de traiter des nouveautés, listons donc rapidement ce que nous avons ici afin de pouvoir nous y référer plus tard :
Mise à
jour
Image
système
Version nouvelle

+ précédente
Timbre à date nouveau

+ précédent
Référence
modèles ciblés
Modèles
ciblés
3.50
3070
3.50

3.40
2020.0924.1830

2020.0313.0216
CY810A
Graph 90+E, fx-CG50
3071
3.50

3.40
2020.0924.1845

2020.0313.0229
CY810F
fx-CG50AU
3.40
3070
3.40

3.30
2020.0918.1757

2020.0313.0229
CY835A
Graph 35+E II
3071
3.40

3.21
2020.0918.1811
2020.0313.0229
CY837A
fx-9860GIII
3072
3.40

3.21
2020.0918.1820

2020.0313.0229
CY838A
fx-9750GIII
3.12
3070
3.12

3.11
2020.0924.1914

2018.0308.1942
LY755A
fx-CG10/20
3071
3.12

3.11
2020.0924.1926

2018.0308.1951
LY755F
fx-CG20AU
2.11
3071
2.08
2015.1201.1207
GY493A
fx-9860GII SD
(
USB Power Graphic 1
)
3072
2.08
2015.1201.1207
GY493B
Graph 95
(
USB Power Graphic 1
)
3073
2.08
2015.1201.1215
GY495A
fx-9860GII
(
USB Power Graphic 1
)
3074
2.08
2015.1201.1219
GY495B
Graph 75
(
USB Power Graphic 1
)
3075
2.08
2015.1201.1223
GY495E
fx-9860G AU
3080
2.11

2.09
2020.0910.1404

2015.1204.1158
GY497A
fx-9860GII SD
(
USB Power Graphic 2
)
3081
2.09
2015.1204.1203
GY497B
Graph 95
(
USB Power Graphic 2
)
3082
2.09
2015.1204.1208
GY498A
fx-9860GIIs
3083
2.11

2.09
2020.0910.1353

2015.1204.1213
GY499A
fx-9860GII
(
USB Power Graphic 2
)
3084
2.09
2015.1204.1218
GY499B
Graph 75+
3085
2.09
2015.1204.1223
GY499E
fx-9860G AU+
3086
2.09
2015.1202.1718
CY802A
Graph 75+E


131691316813157Pour ce qui est simple, nous avons donc :
  • la
    Graph 90+E
    et ses équivalents internationaux
    fx-CG50
    qui passent de la version
    3.40
    du
    13 mars 2020
    à la nouvelle version
    3.50
    compilée le
    24 septembre 2020
  • la
    Graph 35+E II
    qui passe de la version
    3.30
    du
    13 mars 2020
    à la nouvelle version
    3.40
    compilée le
    18 septembre 2020
  • ses pendants internationaux
    fx-9750GIII
    et
    fx-9860GIII
    qui passent directement de la version
    3.21
    du
    13 mars 2020
    à la nouvelle version
    3.40
    compilée le
    18 septembre 2020

13171Quant à la mise à jour
2.11
pour les anciennes générations monochromes
USB Power Graphic 1
et
USB Power Graphic 2
:
  • rien de nouveau pour les modèles de la génération
    USB Power Graphic 1
    (processeur
    SH3
    )
    qui ne seront mis à jour qu'au maximum vers la version
    2.08
    compilée le
    1er décembre 2015
  • rien de nouveau non plus pour les déclinaisons locales à certains pays de la génération
    USB Power Graphic 2
    (
    Graph 75+
    et
    Graph 75+E
    pour la
    France
    ,
    fx-9860G AU+
    pour l'
    Australie
    ,
    fx-9860GIIs
    pour
    Singapour
    )
    qui ne seront mis à jour qu'au maximum vers la version
    2.09
    compilée le
    4 décembre 2015
Ne peuvent être mis à jour vers la nouvelle version
2.11
que les seuls modèles internationaux de la génération
USB Power Graphic 2
:
fx-9860G II
et
fx-9860GII SD
.

Maintenant que nous avons toutes ces bases, découvrons ensemble les nouveautés.








1) Python et casioplot

Go to top

1315513165Commençons par les nouveautés autour de l'application
Python
intégrée apportées à la fois :
  • par la mise à jour
    3.50
    de la dernière génération couleur :
    • Graph 90+E
    • fx-CG50
  • par la mise à jour
    3.40
    de la dernière génération monochrome :
    • Graph 35+E II
    • fx-9860GIII
    • fx-9750GIII
Rappelons que les
fx-9860GIII
et
fx-9750GIII
, équivalents de la
Graph 35+E II
respectivement en Europe et Amérique du Nord, n'ont à la différence de cette dernière pas bénéficié d'une mise à jour intermédiaire
3.30
. En passant directement de la version
3.21
à
3.40
, leur application
Python
bénéficie déjà de tout ce qui a été apporté sur
Graph 35+E II
avec la version
3.30
et que nous t'invitons à aller consulter, et notamment enfin du module de tracé par pixels
casioplot
. :bj:

Passons maintenant aux nouveautés spécifiquement apportées par la dernière version
3.40
ou
3.50
.

Nous avions déjà remarqué que le module de tracé par pixels
casioplot
offrait une fonction
clear_screen()
pour effacer l'écran, fonction parfaitement fonctionnelle mais qui bizarrement n'était pas au catalogue de modules et fonctions accessible via
SHIFT
4
, et les appels à cette fonction donc être saisis à la main caractère par caractère.

Désormais
clear_screen()
est bien disponible au catalogue. :)




2) Python et turtle

Go to top

La dernière mise à jour apportait donc le module de tracé par pixels
casioplot
.
Casio France
diffusait de plus un script
turtle.py
, une réécriture complète en
Python
du module de tracés relatifs
turtle
standard.

Ce choix de passer par un script
turtle.py
additionnel avait toutefois trois inconvénients majeurs :
  • déjà,
    turtle.py
    ne venait pas avec les mises à jour et devait donc être ajouté manuellement dans la calculatrice
  • les fonctions du module
    turtle
    n'étaient pas listées au catalogue ; elles devaient donc être connues et saisies manuellement caractère par caractère :(
  • comme tout fichier additionnel,
    turtle.py
    était de plus inutilisable en mode examen. :'(

Et bien gros changement sur les modèles français
Graph 90+E
et
Graph 35+E II
avec la dernière version, le module
turtle
est désormais directement intégré au système ! :bj:
Il devient donc à la fois :
  • disponible immédiatement
  • décrit au catalogue
  • utilisable en mode examen

13155A noter que cette amélioration semble ne concerner que les modèles français. La
fx-9750GIII
mise à jour ne bénéficie pas de cette amélioration, et probablement pas mieux pour les autres modèles internationaux
fx-9860GIII
et
fx-CG50
. :#non#:

Sur ces modèles il faudra donc continuer à passer par les scripts additionnels que nous te lierons en fin d'article, scripts qui deviendront indisponibles en mode examen.




3) Exemples turtle

Go to top

Ce qui était déjà remarquable avec la réécriture intégrale du module
turtle
par
Casio
, c'est la haute conformité au standard que l'on vérifiait aisément en comparant ce que donne le même script sur ordinateur, et on peut en passant comparer avec les plateformes concurrentes.
Voici quelques exemples utilisant du code
turtle
standard. Nous allons juste mettre dans le code quelques protections concernant les fonctions parfois non définies sur certaines plateformes, afin que leur appel n'empêche pas l'affichage du tracé obtenu. Mais nous ne coderons ici rien pour corriger des incompatibilités avec la norme.
ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

turtle.speed(0)
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

ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

def try_pencolor(c):
  try: turtle.pencolor(c)
  except: pass
  try: turtle.color(c)
  except: pass

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)

try_pencolor("blue")
turtle.penup()
turtle.goto(-180, -50)
turtle.pendown()
koch(4, 360)

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



ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

from math import exp

def try_colormode(m):
  try: turtle.colormode(m)
  except: pass
def try_pencolor(c):
  try: turtle.pencolor(c)
  except: pass
  try: turtle.color(c)
  except: pass

try_colormode(1)
for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  try_pencolor([red, green, blue])
  for i in range(1, 5):
    turtle.forward(60)
    turtle.right(90)
  turtle.right(10)

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

ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

from math import exp

def try_colormode(m):
  try: turtle.colormode(m)
  except: pass
def try_pencolor(c):
  try: turtle.pencolor(c)
  except: pass
  try: turtle.color(c)
  except: pass

try_colormode(1)
turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  try_pencolor([red,green,blue])
  turtle.circle(50-i)
  turtle.right(10)

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

ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

def try_colormode(m):
  try: turtle.colormode(m)
  except: pass
def try_pencolor(c):
  try: turtle.pencolor(c)
  except: pass
  try: turtle.color(c)
  except: pass

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)

try_colormode(1)
turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
try_pencolor((1, 0, 0))
sierp(6, 217)
turtle.penup()
turtle.forward(400)

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

Comme tu peux le voir, les
Graph 90+E
et
Graph 35+E II
comptaient déjà parmi les meilleures solutions sur le critère de la conformité au standard
turtle
, pas d'écart sur ces exemples contrairement à certaines solutions concurrentes ! :bj:

Niveau fonctions dont les appels ont ici été protégés pour palier leur absence sur certaines plateformes, en fait il ne manque pas grand chose aux
Graph 90+E
et
Graph 35+E II
, juste
turtle.colormode()
.




4) Nouveautés turtle

Go to top

Nous remarquons en fait que le module
turtle
désormais intégré est toujours écrit en
Python
, son code étant lisible en clair en mémoire. Et nous notons surtout qu'il s'agit d'une nouvelle version par rapport à celle sortie au printemps dernier, une mise à jour assez majeure si tu compares toutes les différences ci-dessous :
Code: Select all
import casioplot
from math import sqrt
from math import pi
from math import cos
from math import sin
from math import atan2

turtleshapes={"classic":[[-9,5],[-9,4],[-8,4],[-8,3],[-8,2],[-8,-2],[-8,-3],[-8,-4],[-9,-4],[-9,-5],[-7,4],[-7,1],[-7,0],[-7,-1],[-7,-4],[-6,3],[-6,-3],[-5,3],[-5,-3],[-4,2],[-4,-2],[-3,2],[-3,-2],[-2,1],[-2,-1],[-1,1],[-1,-1],[0,0]],"turtle": [[-3,3],[2,3],[-2,2],[-1,2],[0,2],[1,2],[-2,1],[-1,1],[1,1],[0,1],[2,1],[3,1],[-2,0],[-1,0],[0,0],[1,0],[-1,-1],[-2,-1],[0,-1],[1,-1],[2,0],[3,0],[-3,-2],[2,-2]]}
turtle_name="classic"
turtle_data=turtleshapes[turtle_name]
turtle_pos=[0,0]
turtle_angle=0
turtle_color=(0,0,0)
writing=True
pen_size=1
turtle_buffer=[[]]
turtle_speed=5
frame_count=0
turtle_visible=True

def draw_turtle(x,y,a,c):
  global turtle_buffer
  def inbuffer(x,y):
    inlist=False
    for i in range(1,len(turtle_buffer)):
      if x==turtle_buffer[i][0] and y==turtle_buffer[i][1]:
        inlist=True
    return inlist
  if turtle_visible==True:
    u=cos(a*pi/180)
    v=sin(a*pi/180)
    for point in turtle_data:
      xx=x+(point[0]*u-point[1]*v)
      yy=y+(point[1]*u+point[0]*v)
      xpixel=int(round(xx+192))
      ypixel=int(round(-yy+96))
      if (0<=xpixel<=383 and 0<=ypixel<=191):
        if not inbuffer(xpixel,ypixel):
          turtle_buffer+=[[xpixel,ypixel,casioplot.get_pixel(xpixel,ypixel)]]
        casioplot.set_pixel(xpixel,ypixel,c)

def erase_turtle():
  global turtle_buffer
  for i in range(1,len(turtle_buffer)):
    xpixel=turtle_buffer[i][0]
    ypixel=turtle_buffer[i][1]
    if turtle_buffer[i][2]!=None :
      lastcolor=turtle_buffer[i][2]
    else:
      lastcolor=(255,255,255)
    casioplot.set_pixel(xpixel,ypixel,lastcolor)
  turtle_buffer=[[]]

def pen_brush(x,y,turtle_color):
  global frame_count
  erase_turtle()
  xpixel=int(round(x+192))
  ypixel=int(round(-y+96))
  if writing==True and (0<=xpixel<=383 and 0<=ypixel<=191) :
    colorpixel=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
    casioplot.set_pixel(xpixel,ypixel,colorpixel)
    frame_count+=1
    if turtle_speed!=0:
      if frame_count%(turtle_speed*4)==0:
        draw_turtle(x,y,turtle_angle,colorpixel)
        casioplot.show_screen()
    else :
      if frame_count%500==0:
        draw_turtle(x,y,turtle_angle,colorpixel)
        casioplot.show_screen()

def refresh_turtle():
  c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
  erase_turtle()
  draw_turtle(turtle_pos[0],turtle_pos[1],turtle_angle,c)
  casioplot.show_screen()

def back(n):
  forward(-n)

def backward(n):
  back(n)

def bk(n):
  back(n)

def circle(radius,extent=360):
  global  turtle_angle, turtle_pos
  x1=turtle_pos[0]
  y1=turtle_pos[1]
  if round(radius)==0:
    pen_brush(x1,y1,turtle_color)
    turtle_angle+=extent
  elif round(extent,8)==0:
    pen_brush(x1,y1,turtle_color)
  else:
    e=radius/abs(radius)
    theta=extent*pi/180*e
    Rx=cos(theta)
    Ry=sin(theta)
    Dx=radius*sin(turtle_angle*pi/180)
    Dy=-radius*cos(turtle_angle*pi/180)
    xcenter=x1-Dx
    ycenter=y1-Dy
    nbpixelarc=int(round(abs(radius*theta*1.05)))
    angle=turtle_angle
    if nbpixelarc!=0:
      alpha=theta/nbpixelarc
      for k in range(nbpixelarc+1):
        x=xcenter+Dx*cos(alpha*k)-Dy*sin(alpha*k)
        y=ycenter+Dx*sin(alpha*k)+Dy*cos(alpha*k)
        turtle_angle+=alpha*180/pi
        pen_brush(x,y,turtle_color)
    turtle_pos[0]=xcenter+Dx*Rx-Dy*Ry
    turtle_pos[1]=ycenter+Dx*Ry+Dy*Rx
    turtle_angle=angle+extent*e
  refresh_turtle()

def clear():
  erase_turtle()
  casioplot.clear_screen()
  casioplot.show_screen()
  refresh_turtle()

def distance(x,y):
  return sqrt((x-turtle_pos[0])**2+(y-turtle_pos[1])**2)

def down():
  global writing
  writing=True

def fd(d):
  forward(d)

def forward(d):
  global turtle_pos
  dx=d*cos(turtle_angle*pi/180)
  dy=d*sin(turtle_angle*pi/180)
  x1=turtle_pos[0]
  y1=turtle_pos[1]
  if round(abs(d))==0:
    pen_brush(x1+dx,y1+dy,turtle_color)
  elif abs(dx)>=abs(dy):
    e=int(dx/abs(dx))
    m=dy/dx
    p=y1-m*x1
    for x in range(int(round(x1)),int(round(x1+dx)),e):
      pen_brush(x,m*x+p,turtle_color)
  else:
    e=int(dy/abs(dy))
    m=dx/dy
    p=x1-m*y1
    for y in range(int(round(y1)),int(round(y1+dy)),e):
      pen_brush(m*y+p,y,turtle_color)
  turtle_pos[0]+=dx
  turtle_pos[1]+=dy
  refresh_turtle()

def goto(x,y):
  a=turtle_angle
  setheading(towards(x,y))
  forward(distance(x,y))
  setheading(a)
  refresh_turtle()

def heading():
  return turtle_angle

def hideturtle():
  global turtle_visible
  turtle_visible=False
  refresh_turtle()

def home():
  global turtle_pos,turtle_angle
  turtle_pos[0]=turtle_pos[1]=0
  turtle_angle=0
  refresh_turtle()

def ht():
  hideturtle()

def isdown():
  return writing

def isvisible():
  return turtle_visible

def left(a):
  right(-a)

def lt(a):
  right(-a)

def pd():
  down()

def pencolor(*c):
  global turtle_color
  colornames={"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)}
  if c==():
    return turtle_color
  elif c[0] in colornames:
    turtle_color=colornames[c[0]]
  elif isinstance(c[0],(list,tuple)) and len(c[0])==3 and isinstance(c[0][0],(int,float)) and isinstance(c[0][1],(int,float)) and isinstance(c[0][2],(int,float)) and 0<=c[0][0]<=1 and 0<=c[0][1]<=1 and 0<=c[0][2]<=1:
    turtle_color=list(c[0])
  else:
    raise ValueError('error using pencolor : enter a color text or 3 floats between 0 and 1')
  refresh_turtle()

def pendown():
  down()

def pensize(n):
  global pen_size
  pen_size=n
  refresh_turtle()

def penup():
  global writing
  writing=False

def pos():
  return (xcor(),ycor())

def position():
  return (xcor(),ycor())

def pu():
  penup()

def reset():
  global turtle_color,writing,pen_size,speed,turtle_visible
  clear()
  turtle_color=(0,0,0)
  home()
  writing=True
  pen_size=1
  speed=5
  turtle_visible=True
  shape("classic")
  refresh_turtle()

def right(a):
  global turtle_angle
  turtle_angle-=a
  refresh_turtle()

def rt(a):
  right(a)

def seth(a):
  setheading(a)

def setheading(a):
  global turtle_angle
  turtle_angle=a
  refresh_turtle()

def setpos(x,y):
  goto(x,y)
  refresh_turtle()

def setposition(x,y):
  setpos(x,y)

def setx(x):
  global turtle_pos
  turtle_pos[0]=x
  refresh_turtle()

def sety(y):
  global turtle_pos
  turtle_pos[1]=y
  refresh_turtle()

def shape(text=None):
  global turtle_name,turtle_data
  if text==None:
    return turtle_name
  elif text in turtleshapes:
    turtle_name=text
    turtle_data=turtleshapes[text]
  else:
    raise ValueError('available shapes: "classic" or "turtle"')
  refresh_turtle()

def showturtle():
  global turtle_visible
  turtle_visible=True
  refresh_turtle()

def speed(v=None):
  global turtle_speed
  speedwords = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
  if v==None:
    pass
  elif isinstance(v,(int,float)) and (v<=0.5 or v>=10.5):
    turtle_speed=0
  elif isinstance(v,(int,float)) and (0.5<v<10.5):
    turtle_speed=int(round(v))
  elif isinstance(v,str) and v in speedwords:
    turtle_speed=speedwords[v]
  else:
    raise ValueError("Error using function speed: enter a real between 0 & 10")

def st():
  showturtle()

def towards(x,y):
  if round(x-turtle_pos[0],8)==0 and round(y-turtle_pos[1],8)==0:
    return 0
  else:
    return (atan2(y-turtle_pos[1],x-turtle_pos[0])*180/pi)

def up():
  penup()

def width(n):
  pensize(n)

def write(text):
  xpixel=int(round(turtle_pos[0]+192))
  ypixel=int(round(-turtle_pos[1]+96))
  c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
  casioplot.draw_string(xpixel,ypixel,str(text),c,"small")
  casioplot.show_screen()

def xcor():
  return round(turtle_pos[0],6)
def ycor():
  return round(turtle_pos[1],6)
Code: Select all
import casioplot
from math import sqrt
from math import pi
from math import cos
from math import sin
from math import atan2

turtleshapes={"classic":[[-9,5],[-9,4],[-8,4],[-8,3],[-8,2],[-8,-2],[-8,-3],[-8,-4],[-9,-4],[-9,-5],[-7,4],[-7,1],[-7,0],[-7,-1],[-7,-4],[-6,3],[-6,-3],[-5,3],[-5,-3],[-4,2],[-4,-2],[-3,2],[-3,-2],[-2,1],[-2,-1],[-1,1],[-1,-1],[0,0]],"turtle": [[-3,3],[2,3],[-2,2],[-1,2],[0,2],[1,2],[-2,1],[-1,1],[1,1],[0,1],[2,1],[3,1],[-2,0],[-1,0],[0,0],[1,0],[-1,-1],[-2,-1],[0,-1],[1,-1],[2,0],[3,0],[-3,-2],[2,-2]]}
turtle_name="classic"
turtle_data=turtleshapes[turtle_name]
turtle_pos=[0,0]
turtle_angle=0
turtle_color=(0,0,0)
writing=True
pen_pixels=[[0,0]]
turtle_buffer=[]
turtle_speed=5
frame_count=0
turtle_visible=True
pen_size=1

def _draw_turtle(x,y,a,c):
  global turtle_buffer
  def inbuffer(x,y):
    inlist=False
    for i in range(len(turtle_buffer)):
      if x==turtle_buffer[i][0] and y==turtle_buffer[i][1]:
        inlist=True
    return inlist
  if turtle_visible==True:
    u=cos(a*pi/180)
    v=sin(a*pi/180)
    for point in turtle_data:
      xx=x+(point[0]*u-point[1]*v)
      yy=y+(point[1]*u+point[0]*v)
      xpixel=int(round(xx+192))
      ypixel=int(round(-yy+96))
      if (0<=xpixel<=383 and 0<=ypixel<=191):
        if not inbuffer(xpixel,ypixel):
          turtle_buffer+=[[xpixel,ypixel,casioplot.get_pixel(xpixel,ypixel)]]
        casioplot.set_pixel(xpixel,ypixel,c)

def _erase_turtle():
  global turtle_buffer
  for i in range(len(turtle_buffer)):
    xpixel=turtle_buffer[i][0]
    ypixel=turtle_buffer[i][1]
    if turtle_buffer[i][2]!=None :
      lastcolor=turtle_buffer[i][2]
    else:
      lastcolor=(255,255,255)
    casioplot.set_pixel(xpixel,ypixel,lastcolor)
  turtle_buffer.clear()

def _pen_brush(x,y,turtle_color):
  global frame_count
  _erase_turtle()
  xpixel=int(round(x+192))
  ypixel=int(round(-y+96))
  if writing==True and (0<=xpixel<=383 and 0<=ypixel<=191) :
    colorpixel=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))

    for point in pen_pixels:
      casioplot.set_pixel(xpixel+point[0],ypixel+point[1],colorpixel)

    frame_count+=1
    if turtle_speed!=0:
      if frame_count%(turtle_speed*4)==0:
        _draw_turtle(x,y,turtle_angle,colorpixel)
        casioplot.show_screen()
    else :
      if frame_count%500==0:
        _draw_turtle(x,y,turtle_angle,colorpixel)
        casioplot.show_screen()

def _refresh_turtle():
  c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
  _erase_turtle()
  _draw_turtle(turtle_pos[0],turtle_pos[1],turtle_angle,c)
  casioplot.show_screen()

def _conv_angle(a):
  a=a%360
  if a < 0:
    a=360+a
  return a

def back(n):
  forward(-n)

def backward(n):
  back(n)

def bk(n):
  backward(n)

def circle(radius,extent=360):
  global  turtle_angle, turtle_pos
  x1=turtle_pos[0]
  y1=turtle_pos[1]
  if round(radius)==0:
    _pen_brush(x1,y1,turtle_color)
    turtle_angle+=extent
  elif round(extent,8)==0:
    _pen_brush(x1,y1,turtle_color)
  else:
    e=radius/abs(radius)
    theta=extent*pi/180*e
    Rx=cos(theta)
    Ry=sin(theta)
    Dx=radius*sin(turtle_angle*pi/180)
    Dy=-radius*cos(turtle_angle*pi/180)
    xcenter=x1-Dx
    ycenter=y1-Dy
    nbpixelarc=int(round(abs(radius*theta*1.05)))
    angle=turtle_angle
    if nbpixelarc!=0:
      alpha=theta/nbpixelarc
      for k in range(nbpixelarc+1):
        x=xcenter+Dx*cos(alpha*k)-Dy*sin(alpha*k)
        y=ycenter+Dx*sin(alpha*k)+Dy*cos(alpha*k)
        turtle_angle+=alpha*180/pi
        _pen_brush(x,y,turtle_color)
    turtle_pos[0]=xcenter+Dx*Rx-Dy*Ry
    turtle_pos[1]=ycenter+Dx*Ry+Dy*Rx
    turtle_angle=angle+extent*e
  turtle_angle=_conv_angle(turtle_angle)
  _refresh_turtle()

def clear():
  _erase_turtle()
  casioplot.clear_screen()
  casioplot.show_screen()
  _refresh_turtle()

def distance(x,y):
  return sqrt((x-turtle_pos[0])**2+(y-turtle_pos[1])**2)

def down():
  global writing
  writing=True

def fd(d):
  forward(d)

def forward(d):
  global turtle_pos
  dx=d*cos(turtle_angle*pi/180)
  dy=d*sin(turtle_angle*pi/180)
  x1=turtle_pos[0]
  y1=turtle_pos[1]
  if round(abs(d))==0:
    _pen_brush(x1+dx,y1+dy,turtle_color)
  elif abs(dx)>=abs(dy):
    e=int(dx/abs(dx))
    m=dy/dx
    p=y1-m*x1
    for x in range(int(round(x1)),int(round(x1+dx)),e):
      _pen_brush(x,m*x+p,turtle_color)
  else:
    e=int(dy/abs(dy))
    m=dx/dy
    p=x1-m*y1
    for y in range(int(round(y1)),int(round(y1+dy)),e):
      _pen_brush(m*y+p,y,turtle_color)
  turtle_pos[0]+=dx
  turtle_pos[1]+=dy
  _refresh_turtle()

def goto(x,y):
  a=turtle_angle
  setheading(towards(x,y))
  forward(distance(x,y))
  setheading(a)
  _refresh_turtle()

def heading():
  return turtle_angle

def hideturtle():
  global turtle_visible
  turtle_visible=False
  _refresh_turtle()

def home():
  global turtle_angle
  goto(0,0)
  turtle_angle=0
  _refresh_turtle()

def ht():
  hideturtle()

def isdown():
  return writing

def isvisible():
  return turtle_visible

def left(a):
  right(-a)

def lt(a):
  left(a)

def pd():
  down()

def pencolor(*c):
  global turtle_color
  colornames={"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)}
  if c==():
    return turtle_color
  elif c[0] in colornames:
    turtle_color=colornames[c[0]]
  elif isinstance(c[0],(list,tuple)) and len(c[0])==3 and isinstance(c[0][0],(int,float)) and isinstance(c[0][1],(int,float)) and isinstance(c[0][2],(int,float)) and 0<=c[0][0]<=1 and 0<=c[0][1]<=1 and 0<=c[0][2]<=1:
    turtle_color=list(c[0])

  elif len(c)==3 and isinstance(c[0],(int,float)) and isinstance(c[1],(int,float)) and isinstance(c[2],(int,float)) and 0<=c[0]<=1 and 0<=c[1]<=1 and 0<=c[2]<=1:
    turtle_color=list(c)

  else:
    raise ValueError('error using pencolor : enter a color text or 3 floats between 0 and 1')
  _refresh_turtle()

def pendown():
  down()

def pensize(n=None):
  global pen_pixels,pen_size
  penshape=[[0,0],[1,0],[0,1],[-1,0],[0,-1],[1,1],[1,-1],[-1,1],[-1,-1],[2,0],[0,2],[-2,0],[0,-2],[2,1],[1,2],[-2,1],[-1,2],[2,-1],[1,-2],[-2,-1],[-1,-2]]
  if n==None:
    return pen_size
  elif isinstance(n,(int,float)) and n>=0:
    pen_size=n
    if round(n)==0 or round(n)==1 :
      pen_pixels=[[0,0]]
    elif round(n)==2 :
      pen_pixels=penshape[0:5]
    elif round(n)==3 :
      pen_pixels=penshape[0:9]
    elif round(n)==4 :
      pen_pixels=penshape[0:13]
    elif round(n)==5 :
      pen_pixels=penshape[0:21]
    elif round(n)>5 :
      pen_pixels=penshape[0:21]
      pen_size=5
      print('Userwarning: pensize over 5 automatically set to 5.')
  else:
    raise ValueError('Error using function pensize: enter a real between 0 & 5')
  _refresh_turtle()

def penup():
  global writing
  writing=False

def pos():
  return position()

def position():
  return (xcor(),ycor())

def pu():
  penup()

def reset():
  global turtle_color,writing,pen_pixels,turtle_speed,turtle_visible,pen_size
  turtle_color=(0,0,0)
  clear()
  hideturtle()
  penup()
  home()
  pendown()
  writing=True
  pen_size=1
  pen_pixels=[[0,0]]
  turtle_speed=5
  shape("classic")
  turtle_visible=True
  _refresh_turtle()

def right(a):
  global turtle_angle
  if isinstance(a, (int, float)):
    turtle_angle = _conv_angle(turtle_angle-a)
  else:
    raise ValueError('error')
  _refresh_turtle()

def rt(a):
  right(a)

def seth(a):
  setheading(a)

def setheading(a):
  global turtle_angle
  turtle_angle=_conv_angle(a)
  _refresh_turtle()

def setpos(x,y):
  goto(x,y)

def setposition(x,y):
  setpos(x,y)

def setx(x):
  goto(x,turtle_pos[1])

def sety(y):
  goto(turtle_pos[0],y)

def shape(name=None):
  global turtle_name,turtle_data
  if name==None:
    return turtle_name
  elif name in turtleshapes:
    turtle_name=name
    turtle_data=turtleshapes[name]
  else:
    raise ValueError('available shapes: "classic" or "turtle"')
  _refresh_turtle()

def showturtle():
  global turtle_visible
  turtle_visible=True
  _refresh_turtle()

def speed(speed=None):
  global turtle_speed
  speedwords = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
  if speed==None:
    return turtle_speed
  elif isinstance(speed,(int,float)) and (speed<=0.5 or speed>=10.5):
    turtle_speed=0
  elif isinstance(speed,(int,float)) and (0.5<speed<10.5):
    turtle_speed=int(round(speed))
  elif isinstance(speed,str) and speed in speedwords:
    turtle_speed=speedwords[speed]
  else:
    raise ValueError("Error using function speed: enter a real between 0 & 10")

def st():
  showturtle()

def towards(x,y):
  if round(x-turtle_pos[0],8)==0 and round(y-turtle_pos[1],8)==0:
    return 0
  else:
    ang=atan2(y-turtle_pos[1],x-turtle_pos[0])*180/pi
    if ang>=0:
        return (ang)
    else:
        return (360+ang)

def up():
  penup()

def width(n=None):
  return pensize(n)

def write(text):
  _refresh_turtle()
  xpixel=int(round(turtle_pos[0]+192))
  ypixel=int(round(-turtle_pos[1]+96))
  c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
  casioplot.draw_string(xpixel,ypixel,str(text),c,"small")
  casioplot.show_screen()

def xcor():
  return round(turtle_pos[0],6)
def ycor():
  return round(turtle_pos[1],6)


Nous avions remarqué un petit écart avec la fonction
turtle.write()
, cette dernière écrivant le texte fourni dans un rectangle dont la tortue occupe le sommet supérieur gauche, alors que dans le standard c'est le sommet inférieur gauche. Vérifions :
ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE


Code: Select all
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError: import turtle

def try_pencolor(c):
  try: turtle.pencolor(c)
  except: pass
  try: turtle.color(c)
  except: pass

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)
try_pencolor("red")
turtle.penup()
turtle.goto(80,40)
turtle.right(140)
turtle.pendown()
turtle.circle(30)
turtle.penup()
turtle.goto(105,50)
try_pencolor("green")
turtle.pendown()
turtle.circle(-50)
turtle.penup()
try_pencolor("red")
turtle.right(21)
turtle.goto(60,20)
turtle.pendown()
turtle.circle(40,60)
turtle.penup()
try_pencolor("blue")
turtle.goto(-50,15)
turtle.setheading(0)
turtle.pendown()
turtle.write("CASIO")

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

Non finalement pas de changement ici, mais vu en comparaison les énormes écarts que se permettent d'autres plateformes on peut bien passer l'éponge cette fois-ci.

Autre chose que nous avions remarqué, un petit
bug
au niveau de la fonction
turtle.pensize()
qui semblait inopérante :
ordi
Graph 90+E
Graph 35+E II
NumWorks
TI-83 Premium CE
TI-84 Plus CE



Et bien ici bonne nouvelle, la nouvelle version intégrée de
turtle
corrige le problème ! :bj:




5) Python et matplotlib.pyplot

Go to top

Ici aussi
Casio France
diffusait depuis la dernière mise à jour un script
matplotl.py
, une réécriture complète en
Python
du module de tracés par coordonnées
matplotl.pyplot
standard.

Ce choix de passer par un script
matplotl.py
additionnel avait ici encore plusieurs inconvénients majeurs :
  • matplotl.py
    ne venait pas avec les mises à jour et devait donc être ajouté manuellement dans la calculatrice
  • Les fonctions du module
    matplotl
    n'étaient pas listées au catalogue ; elles devaient donc être connues et saisies manuellement caractère par caractère :(
  • Comme tout fichier additionnel,
    matplot.py
    était de plus inutilisable en mode examen. :'(
  • La calculatrice ne gérant que partiellement les noms de fichiers longs, le fichier de script correspondant avait donc été nommé
    matplotl.py
    et non
    matplotlib.pyplot.py
    afin de recpecter la limitation à 8 caractères, ce qui introduisait donc une incompatibilté avec les scripts conçus pour le standard
    matplotlib.pyplot
    .
    La compatibilité avec des scripts conçus pour d'autres plateformes nécessitait un léger effort, quelques lignes d'importation spécifiques en début de script :
    Code: Select all
    try: from matplotlib.pyplot import *
    except ImportError: from matplotl import *

Gros changement en conséquence sur les modèles français
Graph 90+E
et
Graph 35+E II
avec la dernière version, le module est désormais directement intégré au système et de plus renommé correctement en
matplotlib.pyplot
! :bj:
Il devient donc à la fois :
  • disponible immédiatement
  • décrit au catalogue
  • utilisable en mode examen
  • directement utilisable avec les scripts
    matplotlib.pyplot
    conçus pour d'autres plateformes, même plus besoin de modifier les lignes d'importation

13155A noter que cette amélioration semble ici encore ne concerner que les modèles français. La
fx-9750GIII
mise à jour ne bénéficie pas de cette amélioration, et même si nous n'en disposons pas c'est probablement pareil sur les autres modèles internationaux
fx-9860GIII
et
fx-CG50
. :#non#:

Sur ces modèles il faudra donc continuer à passer par les scripts additionnels que nous te lierons en fin d'article, scripts qui seront inutilisables en mode examen.




6) Exemples matplotlib.pyplot

Go to top

Pour une réécriture intégrale, observons ici encore la remarquable compatibilité avec le standard
matplotlib.pyplot
de l'ordinateur, ainsi que ce que donnent les implémentations concurrentes :
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *

x = [119.1, 119.3, 119.5, 119.6, 119.9, 120.0, 120.1, 120.3, 120.4]
y = [1, 3, 4, 3, 1, 3, 1, 3, 1]

bar(x, y, 0.08)
show()

ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *

x = [119.1, 119.3, 119.5, 119.6, 119.9, 120.0, 120.1, 120.3, 120.4]
y = [1, 3, 4, 3, 1, 3, 1, 3, 1]

bar(x, y, 0.08)
show()

ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *

V=[20,40,60,80,100]
P=[307,150,101.7,75.8,61]
axis([0,110,0,350])
plot(V,P,"blue")
text(40,250,"P (kPa) versus V (mL)")
show()

ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *

def f(x):
  return x**3-6*x**2+9*x+1
start = -0.5
end = 4.5
steps = 0.1
x = [start+i*steps for i in range(int((end-start)/steps)+1)]
y = [f(j) for j in x]
plot(x, y)
show()

Comme tu peux le noter, les
Graph 90+E
et
Graph 35+E II
comptent ici encore parmi les meilleures solutions du point de vue de la compatibilité avec le standard
matplotlib.pyplot
, pas d'écart sur ces exemples contrairement à certaines solutions concurrentes ! :bj:




7) Nouveautés matplotlib.pyplot

Go to top

Le module
matplotlib.pyplot
intégré est toujours écrit en
Python
, son code étant lisible en clair en mémoire. Et il s'agit surtout d'une nouvelle version par rapport à celle sortie au printemps dernier, une mise à jour assez majeure selon toutes les différences ci-dessous :
Code: Select all
import casioplot as plt

limits=[40,165,384,0]
fenetre=[0,1,0,1]
points=[[]]
lines=[[]]
textes=[[]]
xmin,xmax,ymin,ymax=0,1,0,1
win_scaling='init'
axis_display='on'
color_auto=['b','r','g','k','m','c','y']
color_count=0

def axis(*L):
    global fenetre,win_scaling,axis_display
    if L==():
        if win_scaling=='auto':
            if xmin==xmax:
                if xmin==0:
                    fenetre[0:2]=[-0.05,0.05]
                else:
                    fenetre[0:2]=[0.95*xmin,1.05*xmin]
            else:
                fenetre[0:2]=[xmin-0.05*(xmax-xmin),xmax+0.05*(xmax-xmin)]
            if ymin==ymax:
                if ymin==0:
                    fenetre[2:4]=[-0.05,0.05]
                else:
                    fenetre[2:4]=[0.95*ymin,1.05*ymin]
            else:
                fenetre[2:4]=[ymin-0.05*(ymax-ymin),ymax+0.05*(ymax-ymin)]
        return fenetre
    elif isinstance(L[0],(list,tuple)) and len(L[0])==4:
        fenetre=list(L[0])
        if fenetre[0]==fenetre[1]:
            if fenetre[0]==0:
                fenetre[0:2]=[-0.05,0.05]
            else:
                fenetre[0:2]=[0.95*fenetre[0],1.05*fenetre[0]]
            raise Exception('Userwarning: attempting to set identical bottom == top in function axis(); automatically expanding.')
        if fenetre[2]==fenetre[3]:
            if fenetre[2]==0:
                fenetre[2:4]=[-0.05,0.05]
            else:
                fenetre[2:4]=[0.95*fenetre[2],1.05*fenetre[2]]
            raise Exception('Userwarning: attempting to set identical bottom == top in function axis(); automatically expanding.')
        win_scaling='fixed'
        axis_display='on'
        return fenetre
    elif L[0]=='off':
        axis_display='off'
    elif L[0]=='on':
        axis_display='on'
    elif L[0]=='auto':
        win_scaling='auto'
        if xmin==xmax:
            if xmin==0:
                fenetre[0:2]=[-0.05,0.05]
            else:
                fenetre[0:2]=[0.95*xmin,1.05*xmin]
        else:
            fenetre[0:2]=[xmin-0.05*(xmax-xmin),xmax+0.05*(xmax-xmin)]
        if ymin==ymax:
            if ymin==0:
                fenetre[2:4]=[-0.05,0.05]
            else:
                fenetre[2:4]=[0.95*ymin,1.05*ymin]
        else:
            fenetre[2:4]=[ymin-0.05*(ymax-ymin),ymax+0.05*(ymax-ymin)]
        return fenetre
    else:
        raise Exception('function axis() : error using arguments')

def text(x,y,txt):
    global textes
    if textes==[[]]:
        textes[0]=[x,y,txt]
    else:
        if [x,y,txt] not in textes :
            textes+=[[x,y,txt]]

def plot(*L,**kwargs):
    global color_count,win_scaling
    # if len(L)==2:
    #     L=([list(L[0]),list(L[1])])
    def plotpoint(x,y,c):
        global points,xmin,xmax,ymin,ymax
        if points==[[]]:
            points[0]=[x,y,c]
            xmin=xmax=x
            ymin=ymax=y
        else:
            if [x,y,c] not in points :
                points+=[[x,y,c]]
                xmin=min(x,xmin)
                xmax=max(x,xmax)
                ymin=min(y,ymin)
                ymax=max(y,ymax)

    def plotline(x1,y1,x2,y2,c):
        global lines,xmin,xmax,ymin,ymax
        if lines==[[]]:
            lines[0]=[x1,y1,x2,y2,c]
            xmin=min(x1,x2)
            xmax=max(x1,x2)
            ymin=min(y1,y2)
            ymax=max(y1,y2)
        else:
            if [x1,y1,x2,y2,c] not in lines :
                lines+=[[x1,y1,x2,y2,c]]
                xmin=min(x1,x2,xmin)
                xmax=max(x1,x2,xmax)
                ymin=min(y1,y2,ymin)
                ymax=max(y1,y2,ymax)

    color=kwargs.get('color',None)
    if color!=None and not color in ['b','r','g','k','m','c','y','w','blue','red','green','black','magenta','cyan','yellow','white']:
        raise ValueError('function plot() : unknown color code')
    if len(L)==2 and isinstance(L[0],(int,float)) and isinstance(L[1],(int,float)):
        plotpoint(L[0],L[1],color)
        if win_scaling=='init':
            win_scaling='auto'
    elif len(L)==2 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(list,tuple)):
        if (len(L[0])==len(L[1])):
            if color==None:
                color=color_auto[color_count%7]
                color_count+=1
            for i in range(len(L[0])-1):
                plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],color)
            if win_scaling=='init':
                win_scaling='auto'
        else:
            raise ValueError('function plot() : x and y must have same dimension')
    elif len(L)==1 and isinstance(L[0],(list,tuple)):
        if color==None:
            color=color_auto[color_count%7]
            color_count+=1
        for i in range(len(L[0])-1):
            plotline(i,L[0][i],i+1,L[0][i+1],color)
        if win_scaling=='init':
            win_scaling='auto'
    elif len(L)==3 and isinstance(L[0],(int,float)) and isinstance(L[1],(int,float)) and isinstance(L[2],(str)):
        color=L[2]
        if (len(color)==2 and color[0] in ['b','r','g','k','m','c','y','w']) and color[1] in ['o','.','+','*','-']:
            plotpoint(L[0],L[1],color[0])
            if win_scaling=='init':
                win_scaling='auto'
        elif color in ['b','r','g','k','m','c','y','w','blue','red','green','black','magenta','cyan','yellow','white']:
            plotpoint(L[0],L[1],color)
            if win_scaling=='init':
                win_scaling='auto'
        elif color in ['o','.','+','*','-']:
            color=color_auto[color_count%7]
            color_count+=1
            plotpoint(L[0],L[1],color)
            if win_scaling=='init':
                win_scaling='auto'
        else:
            raise ValueError('function plot() : available color codes are b,r,g,k,m,c,y,w')
    elif len(L)==3 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(list,tuple)) and isinstance(L[2],(str)):
        if (len(L[0])==len(L[1])):
            color=L[2]
            if (len(color)==2 and color[0] in ['b','r','g','k','m','c','y','w']) and color[1] in ['o','.','+','*','-']:
                for i in range(len(L[0])-1):
                    plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],color[0])
                if win_scaling=='init':
                    win_scaling='auto'
            elif color in ['b','r','g','k','m','c','y','w','blue','red','green','black','magenta','cyan','yellow','white']:
                for i in range(len(L[0])-1):
                    plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],color)
                if win_scaling=='init':
                    win_scaling='auto'
            elif color in ['o','.','+','*','-']:
                color=color_auto[color_count%7]
                color_count+=1
                for i in range(len(L[0])-1):
                    plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],color)
                if win_scaling=='init':
                    win_scaling='auto'
            else:
                raise ValueError('function plot() : available color codes are b,r,g,k,m,c,y,w')
        else:
            raise ValueError('function plot() : x and y must have same dimension')
    elif len(L)==2 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(str)):
        color=L[1]
        if (len(color)==2 and color[0] in ['b','r','g','k','m','c','y','w']) and color[1] in ['o','.','+','*','-']:
            for i in range(len(L[0])-1):
                plotline(i,L[0][i],i+1,L[0][i+1],color[0])
            if win_scaling=='init':
                win_scaling='auto'
        elif color in ['b','r','g','k','m','c','y','w','blue','red','green','black','magenta','cyan','yellow','white']:
            for i in range(len(L[0])-1):
                plotline(i,L[0][i],i+1,L[0][i+1],color)
            if win_scaling=='init':
                win_scaling='auto'
        elif color in ['o','.','+','*','-']:
            color=color_auto[color_count%7]
            color_count+=1
            for i in range(len(L[0])-1):
                plotline(i,L[0][i],i+1,L[0][i+1],color)
            if win_scaling=='init':
                win_scaling='auto'
        else:
            raise ValueError('function plot() : available color codes are b,r,g,k,m,c,y,w')
    else:
        raise Exception('function plot() : error using arguments')

def show():
    global fenetre, limits, points, lines, textes, xmin, ymin, xmax, ymax, win_scaling, axis_display, color_count

    def RGB(c):
        if c=="k" or c=="black":
            return (0,0,0)
        elif c=="b" or c=="blue":
            return (0,0,255)
        elif c=="g" or c=="green":
            return (0,255,0)
        elif c=="r" or c=="red":
            return (255,0,0)
        elif c=="c" or c=="cyan":
            return (0,255,255)
        elif c=="y" or c=="yellow":
            return (255,255,0)
        elif c=="m" or c=="magenta":
            return (255,0,255)
        elif c=="w" or c=="white":
            return (255,255,255)
        else:
            raise ValueError("invalid color code")

    def printable(x,y):
        global limits
        return(limits[0]<=x<=limits[2] and limits[3]<=y<=limits[1])

    def echelle(a,b):
        k=0
        e=abs(b-a)
        while e>=10 :
            e/=10
            k+=1
        while e<1 :
            e*=10
            k-=1
        return k

    def pas(a,b):
        pas=10**echelle(a,b)
        while (abs(b-a))//pas<4:
            pas/=2
        return pas

    def converttopixel(x,y):
        global fenetre,limits
        ax=(limits[2]-limits[0])/(fenetre[1]-fenetre[0])
        bx=limits[0]-ax*fenetre[0]
        xpixel=round(ax*x+bx)
        ay=(limits[3]-limits[1])/(fenetre[3]-fenetre[2])
        by=limits[1]-ay*fenetre[2]
        ypixel=round(ay*y+by)
        return xpixel,ypixel

    color_count=0
    plt.clear_screen()
    if win_scaling=='auto':
        if xmin==xmax:
            if xmin==0:
                fenetre[0:2]=[-0.05,0.05]
            else:
                fenetre[0:2]=[0.95*xmin,1.05*xmin]
        else:
            fenetre[0:2]=[xmin-0.05*(xmax-xmin),xmax+0.05*(xmax-xmin)]
        if ymin==ymax:
            if ymin==0:
                fenetre[2:4]=[-0.05,0.05]
            else:
                fenetre[2:4]=[0.95*ymin,1.05*ymin]
        else:
            fenetre[2:4]=[ymin-0.05*(ymax-ymin),ymax+0.05*(ymax-ymin)]
    if axis_display=='on' or axis_display=='boxplot':
        for i in range(limits[0],limits[2]+1):
            plt.set_pixel(i,limits[1],RGB("k"))
        for j in range(limits[3],limits[1]+1):
            plt.set_pixel(limits[0],j,RGB("k"))
        fenetreb=sorted([fenetre[0],fenetre[1]])+sorted([fenetre[2],fenetre[3]])
        gx=round(fenetreb[0],-echelle(fenetreb[0],fenetreb[1]))
        gy=round(fenetreb[2],-echelle(fenetreb[2],fenetreb[3]))
        if axis_display=='boxplot':
            for i in range(nbre_boite):
                y=fenetre[2]
                xpixel,ypixel=converttopixel(i+1,y)
                plt.set_pixel(xpixel,ypixel+1,RGB("k"))
                plt.set_pixel(xpixel,ypixel+2,RGB("k"))
                plt.set_pixel(xpixel,ypixel+3,RGB("k"))
                plt.draw_string(xpixel,ypixel+13,str(round(i+1,8)),[0,0,0],"small")
        else :
            for i in range(-11,11):
                x=gx+i*pas(fenetreb[0],fenetreb[1])
                y=fenetre[2]
                xpixel,ypixel=converttopixel(x,y)
                if printable(xpixel,ypixel):
                    plt.set_pixel(xpixel,ypixel+1,RGB("k"))
                    plt.set_pixel(xpixel,ypixel+2,RGB("k"))
                    plt.set_pixel(xpixel,ypixel+3,RGB("k"))
                    plt.draw_string(xpixel,ypixel+13,str(round(x,8)),[0,0,0],"small")
        for j in range(-11,11):
            x=fenetre[0]
            y=gy+j*pas(fenetreb[2],fenetreb[3])
            xpixel,ypixel=converttopixel(x,y)
            if printable(xpixel,ypixel):
                plt.set_pixel(xpixel-1,ypixel,RGB("k"))
                plt.set_pixel(xpixel-2,ypixel,RGB("k"))
                plt.set_pixel(xpixel-3,ypixel,RGB("k"))
                plt.draw_string(xpixel-40,ypixel,str(round(y,8)),[0,0,0],"small")
    if points!=[[]]:
        if points[0]==[]:
            del points[0]
        for i in range(len(points)):
            xpixel,ypixel=converttopixel(points[i][0],points[i][1])
            if printable(xpixel,ypixel) and points[i][2]!=None:
                for j in range(-2,3):
                    plt.set_pixel(xpixel+j,ypixel,RGB(points[i][2]))
                    plt.set_pixel(xpixel,ypixel+j,RGB(points[i][2]))
    if textes!=[[]]:
        if textes[0]==[]:
            del textes[0]
        for i in range(len(textes)):
            xpixel,ypixel=converttopixel(textes[i][0],textes[i][1])
            if printable(xpixel,ypixel):
                plt.draw_string(xpixel,ypixel,textes[i][2],[0,0,0],"small")
    if lines!=[[]]:
        if lines[0]==[]:
            del lines[0]
        for i in range(len(lines)):
            xpixel1,ypixel1=converttopixel(lines[i][0],lines[i][1])
            xpixel2,ypixel2=converttopixel(lines[i][2],lines[i][3])
            deltax=abs(xpixel2-xpixel1)
            deltay=abs(ypixel2-ypixel1)
            if deltax==deltay==0:
                if printable(xpixel1,ypixel1):
                    plt.set_pixel(xpixel1,ypixel1,RGB(lines[i][4]))
            if deltax<=1 and deltay<=1:
                if printable(xpixel1,ypixel1):
                    plt.set_pixel(xpixel1,ypixel1,RGB(lines[i][4]))
                    plt.set_pixel(xpixel2,ypixel2,RGB(lines[i][4]))
            if deltax>=deltay and deltax!=0:
                m=(ypixel2-ypixel1)/(xpixel2-xpixel1)
                p=ypixel1-m*xpixel1
                xpixelmin=max(limits[0],min(xpixel1,xpixel2))
                xpixelmax=min(limits[2],max(xpixel1,xpixel2))
                if xpixelmin<=limits[2] and xpixelmax>=limits[0]:
                    for xpixel in range(xpixelmin,xpixelmax+1):
                        ypixel=round(m*xpixel+p)
                        if printable(xpixel,ypixel):
                            plt.set_pixel(xpixel,ypixel,RGB(lines[i][4]))
            if deltay>deltax:
                m=(xpixel2-xpixel1)/(ypixel2-ypixel1)
                p=xpixel1-m*ypixel1
                ypixelmin=max(limits[3],min(ypixel1,ypixel2))
                ypixelmax=min(limits[1],max(ypixel1,ypixel2))
                if ypixelmin<=limits[1] and ypixelmax>=limits[3]:
                    for ypixel in range(ypixelmin,ypixelmax+1):
                        xpixel=round(m*ypixel+p)
                        if printable(xpixel,ypixel):
                            plt.set_pixel(xpixel,ypixel,RGB(lines[i][4]))
    axis([limits[0]-50,limits[2],limits[1]+50,limits[3]])
    axis("off")
    plt.show_screen()
    points=[[]]
    lines=[[]]
    textes=[[]]
    xmin,xmax,ymin,ymax=0,1,0,1
    fenetre=[0,1,0,1]
    axis_display='on'
    win_scaling='init'
    color_count=0

def bar(val,eff,lar=0.8):
    val=list(val)
    eff=list(eff)
    global color_count
    if isinstance(val,(list,tuple)) and isinstance(eff,(list,tuple)):
        if len(val)==len(eff):
            for i in range(len(val)):
                plot([val[i]-lar/2,val[i]-lar/2],[0,eff[i]],color_auto[color_count%7])
                plot([val[i]+lar/2,val[i]+lar/2],[0,eff[i]],color_auto[color_count%7])
                plot([val[i]-lar/2,val[i]+lar/2],[eff[i],eff[i]],color_auto[color_count%7])
            color_count+=1
        else:
            raise ValueError('function bar() : lists must have same dimension')
    elif isinstance(val,(int,float)) and isinstance(eff,(int,float)):
        for i in range(len(val)):
            plot([val[i]-lar/2,val[i]-lar/2],[0,eff[i]],color_auto[color_count%7])
            plot([val[i]+lar/2,val[i]+lar/2],[0,eff[i]],color_auto[color_count%7])
            plot([val[i]-lar/2,val[i]+lar/2],[eff[i],eff[i]],color_auto[color_count%7])
        color_count+=1
    else:
        raise ValueError('function bar() : error using arguments or arguments not available in this version')

def scatter(xlist,ylist):
    xlist=list(xlist)
    ylist=list(ylist)
    global color_count
    if isinstance(xlist,(list,tuple)) and isinstance(ylist,(list,tuple)):
        if len(xlist)==len(ylist):
            for i in range(len(xlist)):
                plot(xlist[i],ylist[i],color_auto[color_count%7])
            color_count+=1
        else:
            raise ValueError('function scatter() : x and y must have same dimension')

    elif isinstance(xlist,(int,float)) and isinstance(ylist,(int,float)):
        plot(xlist,ylist,color_auto[color_count%7])
        color_count+=1
    else:
        raise ValueError('function scatter() : error using arguments or arguments not available in this version')

def boxplotFR(L):
    L=list(L)
    global fenetre,color_count,nbre_boite, axis_display,win_scaling
    print("boxplotFR:definition \nfrancaise du \ndiagramme en boite")
    axis_display='boxplot'
    n=len(L)
    if type(L[0])==int or type(L[0])==float:
        n=1
    nbre_boite=n
    largeur=0.3/n

    def mediane(l):
      l=sorted(l)
      r=len(l)
      if r%2==0:
         return (l[r//2]+l[r//2-1])/2
      else:
         return l[r//2]

    def quartiles(l):
      l=sorted(l)
      r=len(l)
      return (l[r//4],l[(3*r)//4])

    def deciles(l):
      l=sorted(l)
      r=len(l)
      return (l[r//10],l[(9*r)//10])

    for i in range(n):
        if n==1:
            if type(L[0])==int or type(L[0])==float:
              K=L
            else:
                K=L[0]
        else :
            K=L[i]
        if type(K)==int or type(K)==float:
            plot([i+1-largeur,i+1+largeur],[K,K],'r')
        elif type(K[0])==int or type(K[0])==float:
            K=sorted(K)
            p=len(K)
            Q1=quartiles(K)[0]
            Q3=quartiles(K)[1]
            D1=deciles(K)[0]
            D9=deciles(K)[1]
            plot([i+1-largeur,i+1+largeur,i+1+largeur,i+1-largeur,i+1-largeur],[Q1,Q1,Q3,Q3,Q1],'k')
            plot([i+1,i+1],[Q1,D1],'k')
            plot([i+1,i+1],[Q3,D9],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[D1,D1],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[D9,D9],'k')
            plot(i+1,K[0],'k')
            plot(i+1,K[p-1],'k')
            plot([i+1-largeur,i+1+largeur],[mediane(K),mediane(K)],'r')
        elif type(min(L[0]))!=int and type(min(L[0]))!=float:
            raise ValueError('wrong type of argument')
    if type(L[0])==int or type(L[0])==float:
        fenetre=[0,2,min(L)-1,max(L)+1]
        Max=max(L)
    else:
        Min=min(L[0])
        Max=max(L[0])
        for i in range(len(L)):
            if type(L[i])==int or type(L[i])==float:
                if L[i]<Min:
                    Min=L[i]
                if L[i]>Max:
                    Max=L[i]
            else:
                if min(L[i])<Min:
                  Min=min(L[i])
                if max(L[i])>Max:
                  Max=max(L[i])
        fenetre=[0,len(L)+1,Min-1,Max+1]
    win_scaling='fixed'
    text(len(L)+1/4,Max+1/2,"boxplotFR")

def boxplot(L,**kwargs):
    L=list(L)
    global fenetre,color_count,nbre_boite, axis_display,win_scaling
    whis=kwargs.get('whis',1.5)
    axis_display='boxplot'
    n=len(L)
    if type(L[0])==int or type(L[0])==float:
        n=1
    nbre_boite=n
    largeur=0.3/n
    def mediane(l):
        r=1
        if type(l)!=int and type(l)!=float:
            l=sorted(l)
            r=len(l)
            if r%2==0 and r//2>0:
                return (l[r//2]+l[r//2-1])/2,l[:r//2],l[r//2:]
            else:
                return l[r//2],l[:r//2],l[r//2+1:]
        return l,l,l
    if type(L[0])==int or type(L[0])==float:
        if  min(L)==max(L):
            ampl=1
        else:
            ampl=max(L)-min(L)
        fenetre=[0,2,min(L)-ampl/20,max(L)+ampl/20]
    else:
        Min=min(L[0])
        Max=max(L[0])
        for i in range(len(L)):
            if type(L[i])==int or type(L[i])==float:
                if L[i]<Min:
                    Min=L[i]
                if L[i]>Max:
                    Max=L[i]
            else:
                if min(L[i])<Min:
                  Min=min(L[i])
                if max(L[i])>Max:
                  Max=max(L[i])
        if  Min==Max:
            ampl=1
        else:
            ampl=Max-Min
        fenetre=[0,len(L)+1,Min-ampl/20,Max+ampl/20]
    win_scaling='fixed'
    for i in range(n):
        if n==1:
            if type(L[0])==int or type(L[0])==float:
              K=L
            else:
                K=L[0]
        else :
            K=L[i]
        if type(K)==int or type(K)==float:
            plot([i+1-largeur,i+1+largeur],[K,K],'r')
        elif type(K[0])==int or type(K[0])==float:
            K=sorted(K)
            p=len(K)
            Q1,Q3=mediane(mediane(K)[1])[0],mediane(mediane(K)[2])[0]
            down=0
            if Q1-whis*(Q3-Q1)<=K[0]:
                down=0
            else :
                while Q1-whis*(Q3-Q1)>K[down]:
                    down+=1
            up=p-1
            if Q3+whis*(Q3-Q1)>=K[p-1]:
                up=p-1
            else :
                while Q3+whis*(Q3-Q1)<K[up]:
                    up-=1
            plot([i+1-largeur,i+1+largeur,i+1+largeur,i+1-largeur,i+1-largeur],[Q1,Q1,Q3,Q3,Q1],'k')
            plot([i+1,i+1],[Q1,K[down]],'k')
            plot([i+1,i+1],[Q3,K[up]],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[K[down],K[down]],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[K[up],K[up]],'k')
            from math import pi
            from math import cos
            from math import sin
            if down>0:
             for t in range(down):
                x=[i+1+0.05*(fenetre[1])/3*cos(2*j*pi/50) for j in range(50)]
                y=[K[t]+0.05*(fenetre[3]-fenetre[2])/3*sin(2*j*pi/50) for j in range(50)]
                plot(x,y,'k')
            if up<p-1:
                for t in range(p-1-up):
                    x=[i+1+0.05*(fenetre[1])/3*cos(2*j*pi/50) for j in range(50)]
                    y=[K[p-1-t]+0.05*(fenetre[3]-fenetre[2])/3*sin(2*j*pi/50) for j in range(50)]
                    plot(x,y,'k')
            plot([i+1-largeur,i+1+largeur],[mediane(K)[0],mediane(K)[0]],'r')
        elif type(min(L[0]))!=int and type(min(L[0]))!=float:
            raise ValueError('wrong type of argument')

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)
    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
import casioplot as plt
limits=[40,165,384,0]
fenetre=[0,1,0,1]
points=[[]]
lines=[[]]
textes=[[]]
extrem=[0,1,0,1]
win_scaling='init'
axis_display='on'
color_auto=['b','r','g','m','k','c','y']
color_count=0
grid_display='off'
color_grid='grey'
available_colors=['b','r','g','k','m','c','y','w','blue','red','green','black','magenta','cyan','yellow','white','grey','orange','purple','brown','pink']

def axis(*L):
    global fenetre,win_scaling,axis_display
    if len(L)==1 and L[0]=='auto':
        win_scaling='auto'
    if L==() or L[0]=='auto':
        if win_scaling=='auto':
            for i in [0,2]:
                if extrem[i]==extrem[i+1]:
                    if extrem[i]==0:
                        fenetre[i:i+2]=[-0.05,0.05]
                    else:
                        fenetre[i:i+2]=[extrem[i]-0.05*abs(extrem[i]),extrem[i]+0.05*abs(extrem[i])]
                else:
                    fenetre[i:i+2]=[1.05*extrem[i]-0.05*extrem[i+1],1.05*extrem[i+1]-0.05*extrem[i]]
        return fenetre
    elif isinstance(L[0],(list,tuple)) and len(L[0])==4:
        fenetre=list(L[0])
        if fenetre[0]==fenetre[1]:
            if fenetre[0]==0:
                fenetre[0:2]=[-0.05,0.05]
            else:
                fenetre[0:2]=[0.95*fenetre[0],1.05*fenetre[0]]
            print('Userwarning: attempting to set identical bottom == top in function axis(); automatically expanding.')
        if fenetre[2]==fenetre[3]:
            if fenetre[2]==0:
                fenetre[2:4]=[-0.05,0.05]
            else:
                fenetre[2:4]=[0.95*fenetre[2],1.05*fenetre[2]]
            print('Userwarning: attempting to set identical bottom == top in function axis(); automatically expanding.')
        win_scaling='fixed'
        axis_display='on'
        return fenetre
    elif L[0]=='off':
        axis_display='off'
    elif L[0]=='on':
        axis_display='on'
    else:
        raise Exception('function axis() : error using arguments')

def text(x,y,txt):
    global textes
    txt=str(txt)
    if textes==[[]]:
        textes[0]=[x,y,txt]
    else:
        if [x,y,txt] not in textes :
            textes+=[[x,y,txt]]

def plot(*L,**kwargs):
    global color_count,win_scaling
    def plotpoint(x,y,c):
        global points,extrem,win_scaling
        if points==[[]] and lines==[[]]:
            points[0]=[x,y,c]
            extrem=[x,x,y,y]
        else:
            if [x,y,c] not in points :
                points+=[[x,y,c]]
                extrem=[min(x,extrem[0]),max(x,extrem[1]),min(y,extrem[2]),max(y,extrem[3])]
        if win_scaling=='init':
            win_scaling='auto'

    def plotline(x1,y1,x2,y2,c):
        global lines,extrem,win_scaling
        if lines==[[]] and points==[[]]:
            lines[0]=[x1,y1,x2,y2,c]
            extrem=[min(x1,x2),max(x1,x2),min(y1,y2),max(y1,y2)]
        else:
            if [x1,y1,x2,y2,c] not in lines :
                lines+=[[x1,y1,x2,y2,c]]
                extrem=[min(x1,x2,extrem[0]),max(x1,x2,extrem[1]),min(y1,y2,extrem[2]),max(y1,y2,extrem[3])]
        if win_scaling=='init':
            win_scaling='auto'

    def auto(c):
        global color_count
        if (c != None and len(c)==2 and c[0] in available_colors and c[1] in ['o','.','+','*','-']):
            c=c[0]
        if c in [None,'o','.','+','*','-']:
            color=color_auto[color_count%7]
            color_count+=1
            return color
        else:
            return c

    def testcolor(c):
        if (len(c)==2 and c[0] in available_colors and c[1] in ['o','.','+','*','-']) or (c in available_colors+['o','.','+','*','-']) :
            return True
        else:
            raise ValueError('function plot() : unknown color code')

    color=kwargs.get('color',None)
    if color!=None and not color in available_colors:
        raise ValueError('function plot() : unknown color code')
    if len(L)==2 and isinstance(L[0],(int,float)) and isinstance(L[1],(int,float)):
        plotpoint(L[0],L[1],auto(color))
    elif len(L)==2 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(list,tuple)):
        if (len(L[0])==len(L[1])):
            c=auto(color)
            for i in range(len(L[0])-1):
                plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],c)
        else:
            raise ValueError('function plot() : x and y must have same dimension')
    elif len(L)==1 and isinstance(L[0],(list,tuple)):
        c=auto(color)
        for i in range(len(L[0])-1):
            plotline(i,L[0][i],i+1,L[0][i+1],c)
    elif len(L)==3 and isinstance(L[0],(int,float)) and isinstance(L[1],(int,float)) and isinstance(L[2],(str)):
        if testcolor(L[2])==True:
            plotpoint(L[0],L[1],auto(L[2]))
    elif len(L)==3 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(list,tuple)) and isinstance(L[2],(str)):
        if (len(L[0])==len(L[1])):
            if testcolor(L[2])==True :
                c=auto(L[2])
                for i in range(len(L[0])-1):
                    plotline(L[0][i],L[1][i],L[0][i+1],L[1][i+1],c)
        else:
            raise ValueError('function plot() : x and y must have same dimension')
    elif len(L)==2 and isinstance(L[0],(list,tuple)) and isinstance(L[1],(str)):
        if testcolor(L[1])==True :
            c=auto(L[1])
            for i in range(len(L[0])-1):
                plotline(i,L[0][i],i+1,L[0][i+1],c)
    else:
        raise Exception('function plot() : error using arguments')
def show():
    global fenetre, limits, points, lines, textes, extrem, win_scaling, axis_display, color_count, color_grid, grid_display
    def RGB(c):
        colornames={"black":(0,0,0),"k":(0,0,0),"blue":(0,0,255),"b":(0,0,255),"green":(0,255,0),"g":(0,255,0),"red":(255,0,0),"r":(255,0,0),"cyan":(0,255,255),"c":(0,255,255),"yellow":(255,255,0),"y":(255,255,0),"magenta":(255,0,255),"m":(255,0,255),"white":(255,255,255),"w":(255,255,255),"orange":(255,166,0),"purple":(128,0,128),"brown":(166,42,42),"pink":(255,192,202),"grey":(215,215,215)}
        if c in colornames:
            return colornames[c]
        else:
            raise ValueError("invalid color code")

    def printable(X):
        global limits
        return(limits[0]<=X[0]<=limits[2] and limits[3]<=X[1]<=limits[1])
    def echelle(a,b):
        k=0
        e=abs(b-a)
        while e>=10 :
            e/=10
            k+=1
        while e<1 :
            e*=10
            k-=1
        return k
    def pas(a,b):
        pas=10**echelle(a,b)
        while (abs(b-a))//pas<4:
            pas/=2
        return pas
    def converttopixel(X):
        global fenetre,limits
        ax=(limits[2]-limits[0])/(fenetre[1]-fenetre[0])
        bx=limits[0]-ax*fenetre[0]
        xpixel=round(ax*X[0]+bx)
        ay=(limits[3]-limits[1])/(fenetre[3]-fenetre[2])
        by=limits[1]-ay*fenetre[2]
        ypixel=round(ay*X[1]+by)
        return [xpixel,ypixel]
    color_count=0
    plt.clear_screen()
    if win_scaling=='auto':
        for i in [0,2]:
            if extrem[i]==extrem[i+1]:
                if extrem[i]==0:
                    fenetre[i:i+2]=[-0.05,0.05]
                else:
                    fenetre[i:i+2]=[extrem[i]-0.05*abs(extrem[i]),extrem[i]+0.05*abs(extrem[i])]
            else:
                fenetre[i:i+2]=[1.05*extrem[i]-0.05*extrem[i+1],1.05*extrem[i+1]-0.05*extrem[i]]
    if axis_display=='on' or axis_display=='boxplot':
        for i in range(limits[0],limits[2]+1):
            plt.set_pixel(i,limits[1],RGB("k"))
        for j in range(limits[3],limits[1]+1):
            plt.set_pixel(limits[0],j,RGB("k"))
        fenetreb=sorted([fenetre[0],fenetre[1]])+sorted([fenetre[2],fenetre[3]])
        pasx=pas(fenetreb[0],fenetreb[1])
        pasy=pas(fenetreb[2],fenetreb[3])
        gx=round(fenetreb[0],-echelle(fenetreb[0],fenetreb[1]))
        gy=round(fenetreb[2],-echelle(fenetreb[2],fenetreb[3]))
        if axis_display=='boxplot':
            for i in range(nbre_boite):
                pix=converttopixel((i+1,fenetre[2]))
                plt.set_pixel(pix[0],pix[1]+1,RGB("k"))
                plt.set_pixel(pix[0],pix[1]+2,RGB("k"))
                plt.set_pixel(pix[0],pix[1]+3,RGB("k"))
                plt.draw_string(pix[0],pix[1]+13,str(i+1),[0,0,0],"small")
        else :
            for i in range(-10,10):
                x=gx+i*pasx
                pix=converttopixel((x,fenetre[2]))
                if printable(pix):
                    plt.set_pixel(pix[0],pix[1]+1,RGB("k"))
                    plt.set_pixel(pix[0],pix[1]+2,RGB("k"))
                    plt.set_pixel(pix[0],pix[1]+3,RGB("k"))
                    plt.set_pixel(pix[0],pix[1]+1,(1,1,1))
                    if grid_display=='on':
                        for z in range(1,165):
                            if pix[0]!=limits[0]:
                              plt.set_pixel(pix[0],pix[1]-z,RGB(color_grid))
                    plt.draw_string(pix[0],pix[1]+13,'{:.4g}'.format(x),[0,0,0],"small")
        for j in range(-10,10):
            y=gy+j*pasy
            pix=converttopixel((fenetre[0],y))
            if printable(pix):
                plt.set_pixel(pix[0]-1,pix[1],RGB("k"))
                plt.set_pixel(pix[0]-2,pix[1],RGB("k"))
                plt.set_pixel(pix[0]-3,pix[1],RGB("k"))
                if grid_display=='on':
                    for z in range(1,340):
                        if pix[1]!=limits[1]:
                          plt.set_pixel(pix[0]+z,pix[1],RGB(color_grid))
                plt.draw_string(pix[0]-40,pix[1],'{:.4g}'.format(y),[0,0,0],"small")
    if points!=[[]]:
        if points[0]==[]:
            del points[0]
        for i in range(len(points)):
            pix=converttopixel((points[i][0],points[i][1]))
            if printable(pix) and points[i][2]!=None:
                for j in range(-2,3):
                    plt.set_pixel(pix[0]+j,pix[1],RGB(points[i][2]))
                    plt.set_pixel(pix[0],pix[1]+j,RGB(points[i][2]))
    if textes!=[[]]:
        if textes[0]==[]:
            del textes[0]
        for i in range(len(textes)):
            pix=converttopixel((textes[i][0],textes[i][1]))
            if printable(pix):
                plt.draw_string(pix[0],pix[1],textes[i][2],[0,0,0],"small")
    if lines!=[[]]:
        if lines[0]==[]:
            del lines[0]
        for i in range(len(lines)):
            pixels=[converttopixel((lines[i][j],lines[i][j+1])) for j in [0,2]]
            deltax=abs(pixels[1][0]-pixels[0][0])
            deltay=abs(pixels[1][1]-pixels[0][1])
            if deltax<=1 and deltay<=1:
                if printable((pixels[0][0],pixels[0][1])):
                    plt.set_pixel(pixels[0][0],pixels[0][1],RGB(lines[i][4]))
                    plt.set_pixel(pixels[1][0],pixels[1][1],RGB(lines[i][4]))
            else:
                if deltax>=deltay:
                    j=0
                else:
                    j=1
                m=(pixels[1][1-j]-pixels[0][1-j])/(pixels[1][j]-pixels[0][j])
                p=pixels[0][1-j]-m*pixels[0][j]
                pix_extrem=(max(limits[0],min(pixels[0][0],pixels[1][0])),min(limits[2],max(pixels[0][0],pixels[1][0])),max(limits[3],min(pixels[0][1],pixels[1][1])),min(limits[1],max(pixels[0][1],pixels[1][1])))
                if pix_extrem[2*j]<=limits[2-j] and pix_extrem[2*j+1]>=limits[-j]:
                    pix=[0,0]
                    for pix[j] in range(pix_extrem[2*j],pix_extrem[2*j+1]+1):
                        pix[1-j]=round(m*pix[j]+p)
                        if printable(pix):
                            plt.set_pixel(pix[0],pix[1],RGB(lines[i][4]))
    axis([limits[0]-50,limits[2],limits[1]+50,limits[3]])
    axis("off")
    plt.show_screen()
    points=[[]]
    lines=[[]]
    textes=[[]]
    extrem=[0,1,0,1]
    fenetre=[0,1,0,1]
    axis_display='on'
    win_scaling='init'
    color_count=0
    grid_display='off'

def bar(val,eff,width=0.8):
    global color_count
    if isinstance(val,(tuple)):
        val=list(val)
    if isinstance(eff,(tuple)):
        eff=list(eff)
    if isinstance(val,(int,float)):
        val=[val]
    if isinstance(eff,(int,float)):
        eff=[eff]
    if isinstance(val,(list)) and isinstance(eff,(list)):
        if len(val)==len(eff):
            for i in range(len(val)):
                plot([val[i]-width/2,val[i]-width/2],[0,eff[i]],color_auto[color_count%7])
                plot([val[i]+width/2,val[i]+width/2],[0,eff[i]],color_auto[color_count%7])
                plot([val[i]-width/2,val[i]+width/2],[eff[i],eff[i]],color_auto[color_count%7])
            color_count+=1
        else:
            raise ValueError('function bar() : lists must have same dimension')
    else:
        raise ValueError('function bar() : error using arguments')

def scatter(xlist,ylist):
    global color_count
    if isinstance(xlist,(tuple)):
        xlist=list(xlist)
    if isinstance(ylist,(tuple)):
        ylist=list(ylist)
    if isinstance(xlist,(int,float)):
        xlist=[xlist]
    if isinstance(ylist,(int,float)):
        ylist=[ylist]
    if isinstance(xlist,(list)) and isinstance(ylist,(list)):
        if len(xlist)==len(ylist):
            for i in range(len(xlist)):
                plot(xlist[i],ylist[i],color_auto[color_count%7])
            color_count+=1
        else:
            raise ValueError('function scatter() : x and y lists must have same dimension')
    else:
        raise ValueError('function scatter() : error using arguments')

def hist(x,bins=10,**kwargs):
    global color_count
    hist_type=kwargs.get('hist_type','std')
    if hist_type not in ['fr','std']:
        raise ValueError('function hist() : hist_type must be std or fr')
    if isinstance(x,(tuple,list)):
        x=sorted(list(x))
    if isinstance(bins,(tuple)):
        bins=list(bins)
    if isinstance(x,(int,float)):
        x=[x]
    if isinstance(bins,(int)) and bins>=1:
        if x[-1]!=x[0]:
            bins=[round(x[0]+k*(x[-1]-x[0])/bins,8) for k in range(bins+1)]
        else :
            bins=[round(x[0]-0.5+k/bins,8) for k in range(bins+1)]
    if isinstance(bins,(list)) and bins!=[]:
        bins=sorted(bins)
        qt=[]
        for i in range(len(bins)-1):
            if i==len(bins)-2:
                eff=len([val for val in x if bins[i]<=val<=bins[i+1]])
            else:
                eff=len([val for val in x if bins[i]<=val<bins[i+1]])
            if hist_type=='fr':
                if abs(bins[i+1]-bins[i])>1e-8:
                    eff=eff/(bins[i+1]-bins[i])
                else :
                    raise ValueError('function hist(,hist_type=''fr'') : bins cannot contain 2 identical values')
            qt+=[eff]
            plot([bins[i],bins[i],bins[i+1],bins[i+1]],[0,eff,eff,0],color_auto[color_count%7])
        color_count+=1
    else:
        raise ValueError('function hist() : error using arguments')
    return qt,bins

def boxplot(L,**kwargs):
    L=list(L)
    global fenetre,nbre_boite,color_count,axis_display,win_scaling
    boxplot_type=kwargs.get('boxplot_type','std')
    if boxplot_type not in ['fr','std']:
        raise ValueError('function boxplot() : boxplot_type must be std or fr')
    def mediane(l,p):
        if p%2==0:
            return (l[p//2]+l[p//2-1])/2
        else:
            return l[p//2]
    def quantiles(l,p,r):
        if boxplot_type=='fr':
            if p%r==0:
                return (l[p//r-1],l[((r-1)*p)//r-1])
            else:
                return (l[p//r],l[((r-1)*p)//r])
        if boxplot_type=='std':
            def percentile(N, q):
                k = (len(N)-1) * q
                f = int(k)
                c = int(k)+1
                if f == k:
                    return N[int(k)]
                d0 = N[f] * (c-k)
                d1 = N[c] * (k-f)
                return d0+d1
            return (percentile(l,0.25),percentile(l,0.75))
    whis=kwargs.get('whis',1.5)
    if whis<0:
        whis=0
    axis_display='boxplot'
    n=len(L)
    if isinstance(L[0],(int,float)):
        n=1
        Max,Min=max(L),min(L)
        if  Max==Min:
            ampl=1
        else:
            ampl=Max-Min
        fenetre=[0,2,Min-ampl/20,Max+ampl/20]
    else:
        Max,Min=max([max(L[i]) for i in range(len(L))]),min([min(L[i]) for i in range(len(L))])
        if  Min==Max:
            ampl=1
        else:
            ampl=Max-Min
        fenetre=[0,len(L)+1,Min-ampl/20,Max+ampl/20]
    nbre_boite,largeur=n,0.3/n
    win_scaling='fixed'
    for i in range(n):
        if n==1:
            if isinstance(L[0],(int,float)):
                K=L
            else:
                K=L[0]
        else :
            K=L[i]
        if isinstance(K,(int,float)):
            plot([i+1-largeur,i+1+largeur],[K,K],'r')
        elif isinstance(K[0],(int,float)):
            K,p=sorted(K),len(K)
            med=mediane(K,p)
            Q1,Q3=quantiles(K,p,4)
            if boxplot_type=='std':
                down,up=0,p-1
                while Q1-whis*(Q3-Q1)>K[down]:
                    down+=1
                while Q3+whis*(Q3-Q1)<K[up]:
                    up-=1
                left_whis,right_whis=K[down],K[up]
                if Q1<K[down]:
                    left_whis=Q1
                if Q3>K[up]:
                    right_whis=Q3
            if boxplot_type=='fr':
                D1,D9=quantiles(K,p,10)
                down=K.index(D1)
                up=K.index(D9)
                left_whis,right_whis=K[down],K[up]
                while(up<p-1 and K[up]==K[up+1]):
                  up=up+1
                  right_whis=K[up]
            plot([i+1-largeur,i+1+largeur,i+1+largeur,i+1-largeur,i+1-largeur],[Q1,Q1,Q3,Q3,Q1],'k')
            plot([i+1,i+1],[Q1,left_whis],'k')
            plot([i+1,i+1],[Q3,right_whis],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[left_whis,left_whis],'k')
            plot([i+1-largeur/2,i+1+largeur/2],[right_whis,right_whis],'k')
            if down>0 or up<p-1:
                from math import pi,cos,sin
                Z=[i for i in range(down)]+[j for j in range(up+1,p)]
                for t in Z:
                    x=[i+1+0.05*(fenetre[1])/3*cos(2*j*pi/50) for j in range(50)]
                    y=[K[t]+0.05*(fenetre[3]-fenetre[2])/3*sin(2*j*pi/50) for j in range(50)]
                    plot(x,y,'k')
            plot([i+1-largeur,i+1+largeur],[med,med],'r')
        else:
            raise ValueError('wrong type of argument')

def arrow(x,y,dx,dy,**kwargs):
    global win_scaling
    a,b=x+dx,y+dy
    win_scaling='fixed'
    color=kwargs.get('ec','k')
    color=kwargs.get('edgecolor',color)
    headcolor=kwargs.get('fc','b')
    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 abs(dx)<0.00001:
        dx=0
    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)
        for i in range(15):
            plot((a-(i/15)*L/2,a-(i/15)*L/2),(b,b+(15-i)/15*c*l),headcolor)
            plot((a+i/15*L/2,a+i/15*L/2),(b,b+(15-i)/15*c*l),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),color)
        for i in range(15):
            plot((a,a+(15-i)/15*c*l),(b-i/15*L/2,b-i/15*L/2),headcolor)
            plot((a,a+(15-i)/15*c*l),(b+i/15*L/2,b+i/15*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 (a-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),color)
        plot((a,X),(b,Y),headcolor)
        listeX=[]
        listeY=[]
        if abs(X-T[0])<0.000001:
            for i in range(15):
                listeX+=[T[0]+i*(a-T[0])/15]+[T[0]]
                listeY+=[-listeX[2*i]/m+k]+[-T[0]/m+k+i*(Y+T[0]/m-k)/15]
        else:
            M=(Y+T[0]/m-k)/(X-T[0])
            P=Y-M*X
            for i in range(15):
                listeX+=[T[0]+i*(a-T[0])/15]+[T[0]+i*(X-T[0])/15]
                listeY+=[-listeX[2*i]/m+k]+[listeX[2*i+1]*M+P]
        plot(listeX,listeY,headcolor)
        listeX=[]
        listeY=[]
        if abs(X-T[1])<0.000001:
            for i in range(15):
                listeX+=[T[1]+i*(a-T[1])/15]+[T[1]]
                listeY+=[-listeX[2*i]/m+k]+[-T[1]/m+k+i*(Y+T[1]/m-k)/15]
        else:
            M=(Y+T[1]/m-k)/(X-T[1])
            P=Y-M*X
            for i in range(15):
                listeX+=[T[1]+i*(a-T[1])/15]+[T[1]+i*(X-T[1])/15]
                listeY+=[-listeX[2*i]/m+k]+[listeX[2*i+1]*M+P]
        plot(listeX,listeY,headcolor)

def grid(*a,**kwargs):
    global color_grid,grid_display
    color=kwargs.get('color',None)
    if a==():
        affichage=a
    else:
        affichage=a[0]
    if color!=None:
        color_grid=color
        affichage='on'
    if color not in available_colors:
        color_grid='grey'
    if affichage==():
        if grid_display=='on':
            grid_display='off'
        else:
            grid_display='on'
    elif affichage=='on' or affichage=='True' or affichage==True or affichage=='true':
        grid_display='on'
    elif affichage=='off' or affichage=='False' or affichage==False or affichage=='false':
        grid_display='off'
    else:
        raise ValueError('string must be one of : "on","off","True",or "False"')


Donc quelles nouveautés dans tout ça ? Revenons sur le tracé de diagrammes en boîte à l'aide de la fonction
boxplot()
:
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *

Val=[1,2,2,11,8,9,15,18,20,9,2,5,6,7,8,9,5,9]

boxplot(Val)
show()

Petit problème concernant donc la fonction
boxplot()
standard de
matplotlib.pyplot
, les diagrammes en boîte qu'elle trace ne sont pas conformes à ceux enseignés au lycée français.
Afin d'y remédier,
Casio
avait ajouté avec sa propre fonction
boxplotFR()
.
On pouvait toutefois regretter un écart par rapport au standard.

Dans le nouveau
matplotlib.pyplot
intégré,
Casio
fait un effort sur ce dernier point. La fonction
boxplotFR()
est supprimée, remplacée par un paramètre nommé
boxplot_type
pouvant être passé à la fonction
boxplot()
, pouvant prendre les valeurs
"std"
ou
"fr"
. :)
L'appel équivalent à boxplotFR(l) est donc boxplot(l, boxplot_type="fr") avec la nouvelle version.

Nous avons donc vu plus haut le diagramme en barres à l'aide de la fonction
bar()
. Et bien grosse nouveauté du
matplotlib.pyplot
intégré, nous avons droit à une nouvelle fonction cette fois-ci pour les histogrammes,
hist()
: :bj:
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
from matplotlib.pyplot import *

x = [119.1, 119.3, 119.5, 119.6, 119.9, 120.0, 120.1, 120.3, 120.4]
y = [1, 3, 4, 3, 1, 3, 1, 3, 1]

l = []
for i in range(len(x)):
  for j in range(y[i]):
    l.append(x[i])

hist(l)
show()

Si tu regardes bien, tu noteras que la fonction
hist()
de
matplotlib.pyplot
ne respecte pas la définition française des histogrammes, à savoir que c'est l'aire des bandes qui indique la valeur.

Et bien nouvel effort remarquable de
Casio
pour concilier le standard
matplotlib.pyplot
et l'enseignement français, il te suffira ici encore de passer le paramètre nommé hist_type="fr" pour obtenir le bon histogramme. :)

Autre ajout, la fonction
grid()
pour tracer un quadrillage : :)
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
from matplotlib.pyplot import *

x = [1, 2, 3, 4, 5, 6, 7]
y = [12, 17, 35, 29, 13, 9, 5]
bar(x, y, 0.5)
grid()
show()

Peut-être serait-il bon de remplir les barres afin d'en faciliter la lecture graphique, notamment sur
Graph 90+E
.

Nous avons également plusieurs corrections de
bugs
, sur les fonctions
axis()
,
boxplot()
et
arrow()
entre autres.

Intéressons-nous à la fonction
arrow()
:
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
from matplotlib.pyplot import *

arrow(0,0,.6,.6,head_width=.4,head_length=.5)
show()

Casio
nous offrait donc déjà le tracé de pointes de flèches de vecteurs le plus proche du standard.

Toutefois,
Casio
a quand même souhaité améliorer la chose. Avec le nouveau
matplotlib.pyplot
intégré de la
Graph 90+E
, ces pointes font l'objet d'un remplissage.

Ce n'est pas le plus embêtant, nous allons y venir, mais cet ajout est assez gourmand en temps d'exécution. Le tracé de notre exemple de vecteur nécessite dans les
2,5s
avec l'ancien
matplotl.py
additionnel, et désormais
7s
avec le nouveau
matplotlib.pyplot
intégré.

Nous avions déjà noté plusieurs bugs concernant la fonction
arrow()
:
  • pointe de flèche tracée de la mauvaise couleur dans certains cas
  • pointe de flèche tracée à l'envers dans certains cas
ordi
Graph 90+E
Graph 35+E II
NumWorks


Code: Select all
try:
  from matplotlib.pyplot import *
except ImportError:
  from matplotl import *
from math import cos, sin, pi, sqrt

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, ts, ec, fc):
  hw = sqrt(rx * ry) * ts / 100
  hl = hw * 2
  for k in range(0, 360, 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, edgecolor=ec, facecolor=fc)

rotarrow(.25, 0, .7, .7, 15, 'r', 'b')
axis([-.65,1.15,-1,1])
show()

La nouvelle version
matplotlib.pyplot
intégrée corrige ces problèmes ! :bj:

Quelque chose de bien embêtant par contre, et que ce changement sur
arrow()
met en évidence, c'est que malgré les
1 Mio
de
heap (tas)
de la
Graph 90+E
nous ne sommes pas loin d'une erreur de mémoire à l'exécution.

Réduisons progressivement le pas angulaire dans notre appel de
rotarrow()
, 15, 14, 13... 12 pour le tracé d'un champ radial de
$mathjax$\frac{360}{12}=30$mathjax$
vecteurs marche encore.
Et puis soudainement avec 11 pour le tracé d'un champ de 32 vecteurs, ça ne marche plus avec le nouveau
matplotlib.pyplot
intégré, alors que cela fonctionnait parfaitement avec l'ancien
matplotl.py
additionnel. :o

Un champ d'une 30aine de vecteurs, ce n'est pas inimaginable en Physique-Chimie, c'est bien embêtant.

Et ce n'est pas juste une légère variation de la limite, avec l'ancien
matplotl.py
additionnel aucun problème pour 180 vecteurs.

Mais que se passe-t-il ?

Selon notre analyse
rapide
du code
Python
de
matplotlib.pyplot
, tout vient du fait que les tracés sont différés, uniquement effectués à l'appel de
show()
.
Tous nos appels rajoutent à des listes globales de primitives à tracer
(points, lines, textes...)
.
Et avec le nouveau
matplotlib.pyplot
intégré viennent plein d'éléments suplémentaires dans la liste
lines
afin de remplir les différentes pointes de flèches de vecteurs.

Or comme
matplotlib.pyplot
est écrit en
Python
, ces listes globales sont des objets
Python
, et par conséquent comme nous l'avons déjà vu maintes fois ils sont très gourmands en mémoire.

Casio
gagnerait sans doute soit à optimiser ce stockage global, soit à passer à une implémentation native de
matplotlib.pyplot
maintenant que c'est de toutes façons intégré au système. Ce sera certes dommage pour nous de ne plus avoir accès au code source, mais si cela peut arranger les utilisateurs c'est l'essentiel.




8) Bilan modules Python

Go to top

Suite à ces ajouts
Python
majeurs, petit bilan de la richesse des solutions
Python
disponibles sur calculatrices.

Nous compterons les éléments offerts par chaque module à l'aide des scripts suivants :
Code: Select all
from autopfrm import *

pf = get_pf()
sh_inf = shell_infos(pf)

unsafe = ()
if pf == 4: #HP Prime
  unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
  unsafe = ('sys.argv', 'sys.path')

if pf >= 0:
  curline=0
  _p = print
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1
    if sh_inf[1]:
        stlines += sh_inf[2]*int(len(st)/sh_inf[1])
    if curline+stlines>=sh_inf[0]:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
  global curline, found
  pitm_name=sstr(pitm)
  if(reset):
    curline=0
    found = []
    pitm_name_l=[pitm_name]
    pitm_str_l=[str(pitm)]
    pitm_val_l=[pitm]
  hd="."*(len(pitm_name_l)-1)
  c = 0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
  except: pass
  for itm in l:
    isFound = itm[0] in found
    c += not isFound
    isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isFound:
      found.append(itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
      pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
      pitm_name_l2.append(itm[0])
      pitm_val_l2.append(itm[1])
      pitm_str_l2.append(itm[2])
      c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
  return c

def explmod(s):
  global found
  module = __import__(s)
  found = []
  return explmodr(module)
Code: Select all
# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

#returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not
def shell_infos(pf):
  #NW small: [00] 12.5x30 -> 16   x 42
  #HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14  x39 -> 18.5 x 45
  #HP big  : [03] 11.5x39 -> 09   x 35 [12] 14  x39 -> 11   x 35
  #                                       uPy     uPy
  #               G352            CPy uPy KhiCAS--------------->  CAS
  #           NW  G90 CE  CX2 HP  GXX NS  NS  NS  NW  NW  G90 G352HP
  l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14)
  l_vcols =  (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39)
  b_vcr = 0b1111100
  if pf >= 0:
    return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
  else:
    return max(l_vlines), max(l_vcols), 1


L'appel explmod('nom_module') explore le module en question et en compte les différents éléments internes, en évitant les doublons. Nous noterons en rouge les modules inaccessibles en mode examen :
TI-
83PCE
TI-
Python
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
83PCE
TI-
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+E II

Num
Works

Num
Works


builtins
array
(u)binascii
board
cmath
(u)collections
(u)ctypes
(u)errno
gc
(u)hashlib
(u)heapq
(u)io
(u)json
linalg
math
matplotlib
.pyplot
micropython
numpy
os
(u)random
(u)re
storage
(u)struct
sys
time
(u)timeq
turtle
(u)zlib
TOTAL
152
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
26
.
.
.
405
153
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
26
.
.
.
406
153
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
28
.
.
.
406
166
33
33
.
40
48
60
68
36
32
32
.
.
.
69
.
.
41
.
.
36
35
.
.
80
40
.
.
.
849
141
.
.
.
.
.
.
.
.
.
.
.
.
.
47
24
59
.
.
.
30
.
.
.
.
.
.
114
.
391
146
.
.
.
34
.
.
.
.
.
.
.
.
.
63
25
22
29
.
.
31
.
.
.
.
25
.
62
.
437
165
32
.
.
40
.
.
68
36
.
.
.
.
.
69
.
.
37
.
.
.
.
.
.
80
.
.
.
.
527
154
27
.
22
35
25
.
.
30
.
.
.
.
.
64
.
.
29
.
38
31
.
45
.
71
31
.
.
.
602
160
30
.
.
38
.
.
.
33
.
.
.
.
.
67
.
.
29
.
.
.
.
.
.
62
.
.
.
.
419
165
.
31
.
38
46
66
66
34
30
30
45
31
67
69
.
44
34
81
28
34
34
.
32
73
.
.
82
32
1192
155
30
.
.
38
.
.
.
33
.
.
.
.
.
67
.
.
32
.
.
34
.
.
.
55
.
.
.
.
444
146
.
.
.
34
.
.
.
.
.
.
.
.
.
63
25
22
29
.
27
31
.
.
.
.
25
.
62
.
472
168
.
34
.
41
49
69
.
37
30
33
48
34
70
72
.
47
38
46
31
37
37
.
35
77
.
34
85
35
1187
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
Nspire
CX


Num
Works

Num
Works


analogin:44
analogout:46
bbport:40
brightns:29
ce_box:32
ce_chart:58
ce_quivr:41
ce_turtl:65

color:30
colorinp:39
conservo:45
dht:45
digital:46
led:45
light:30
lightlvl:44
loudness:44
magnetic:46
mb_butns:38
mb_disp:40
mb_grove:51
mb_music:37
mb_neopx:54
mb_pins:48
mb_radio:40
mb_sensr:54
microbit:28

moisture:44
potentio:44
power:45
ranger:43
relay:45
rgb:45
rgb_arr:51
sound:29
squarewv:44
temperat:43
thermist:44
ti_graphics:67
ti_hub:42
ti_plotlib:78
ti_rover:79
ti_system:34
speaker:35
timer:35
vernier:44
vibmotor:45
analogin:44
analogout:46
bbport:40
brightns:29
ce_box:32
ce_chart:58
ce_quivr:41
ce_turtl:65
color:30
colorinp:39
conservo:45
dht:45
digital:46
led:45
light:30
lightlvl:44
loudness:44
magnetic:46
mb_butns:38
mb_disp:40
mb_grove:51
mb_music:37
mb_neopx:54
mb_pins:48
mb_radio:40
mb_sensr:54
microbit:28
moisture:44
potentio:44
power:45
ranger:43
relay:45
rgb:45
rgb_arr:51
sound:29
squarewv:44
temperat:43
thermist:44
ti_graphics:67
ti_hub:42
ti_plotlib:78
ti_rover:79
ti_system:34
speaker:35
timer:35
vernier:44
vibmotor:45
ti_draw:54
ti_hub:193
ti_image:53
ti_innovator:48
ti_picture:35
ti_plotlib:90
ti_rover:142
ti_st:41
ti_system:83
casioplot
ion:72
kandinsky:28
prime:30
nsp:10
arit:38
cas:28
graphic:55
nsp:37
ion:72
kandinsky:28
arit:41
cas:31
graphic:58
nsp:32
1509-
2095
2095
739
28
100
30
10
158
100
162


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

Un net progrès même si cela ne renverse pas la tendance, la solution
Python
de
Casio
est désormais intégralement disponible en mode examen ! :bj:

Casio
n'a sans doute pas la solution
Python
la plus riche, mais on peut quand même noter un soin méticuleux à rester aussi proche que possible du standard et donc faciliter la vie des élèves et des enseignants en ne leur rajoutant pas de travail, préoccupation que l'on ne trouve pas chez tout-le-monde. :D




9) Nouveaux modes examens

Go to top

Nous abordons maintenant l'autre grosse nouveauté, et la raison pour laquelle la mise à jour de
Casio
est ici globale, concernant également des modèles d'avant-dernière génération.
Les changements dont il est question ici ne concernent pas les modèles spécifiques à la France, uniquement les
fx-9860GII
,
fx-9750GIII
,
fx-9860GIII
,
fx-CG10
,
fx-CG20
et
fx-CG50
.

Sur ces modèles, lorsque l'on demande l'accès au mode examen, l'écran confirmant le succès de l'opération affiche désormais le numéro de version du système de la calculatrice.
Particulièrement utile hors de France dans les pays où ce sont les surveillants qui activent le mode examen des candidats, ou encore pour les examens qui exigent d'installer la dernière version système, une version système récente ou encore une version système spécifique.
Cela permet de s'assurer que le candidat n'utilise pas une version interdite, plus ancienne ou même obsolète qui présenterait des failles dans le mode examen.

Mais bien évidemment, lorsque ce sont les candidats qui activent le mode examen en début d'épreuve, impossible d'avoir les yeux sur tous les écrans.

Casio
avait également prévu quelque chose pour ça, un écran d'information sur le mode examen accessible via
ALPHA
(-)
, non fonctionnel sur les modèles français.
Cet écran indiquait déjà le temps écoulé depuis l'activation du mode examen, permettant ainsi de repérer certaines tentatives de fraude. Notamment les candidats qui auraient activé le mode examen avant l'épreuve et donc potentiellement réinjecté toutes les données de leur choix, et d'une façon ou d'une autre trompé le surveillant sur l'état de la calculatrice en arrivant à leur épreuve
(en dissimulant le clignotement de la diode et faisant mine d'appuyer sur les touches ou peu importe)
.

Et bien nouveauté, cet écran d'information indique dorénavement lui aussi la version de système d'exploitation utilisé. Le surveillant peut donc désormais tout vérifier à n'importe quel moment de l'épreuve en seulement 2 touches. :bj:

Mais ce n'est pas tout. Historiquement chez
Casio
nous avions 2 modes examen aux comportements différents répartis sur différents modèles :
  • mode examen français
    (
    Graph 35+E II
    ,
    Graph 75+E
    ,
    Graph 90+E
    )
  • mode examen international
    (
    fx-9860GII
    ,
    fx-9750GIII
    ,
    fx-9860GIII
    ,
    fx-CG10
    ,
    fx-CG20
    ,
    fx-CG50
    )

Avec la mise à jour
3.30
,
Casio
avait rajouté un 2ème mode examen sur la
fx-CG50
(mais pas sur la
Graph 90+E
)
, portant donc le nombre total de modes examens différents à 3.
Le mode examen historique de la
fx-CG50
était renommé
"mode examen 1"
, et le nouveau
"mode examen 2"
.
  • mode examen français
    (
    Graph 35+E II
    ,
    Graph 75+E
    ,
    Graph 90+E
    )
  • mode examen international / mode examen 1
    (
    fx-9860GII
    ,
    fx-9750GIII
    ,
    fx-9860GIII
    ,
    fx-CG10
    ,
    fx-CG20
    ,
    fx-CG50
    )
  • mode examen 2
    (
    fx-CG50
    )
    qui avait l'avantage d'autoriser l'usage de l'appli additionnelle officielle
    Graphe 3D

Avec les dernières mises à jour traitées aujourd'hui, c'est un festival :
  • 2 nouveaux modes examen sont rajoutés, portant le total à 5 modes examen différents :
    • un pour les
      Pays-Bas
      qui a la particularité d'interdire le calcul exact sur les irrationnels
    • un pour le
      Texas
      qui a la particularité d'interdire les représentations graphiques d'inéquations, et oui
      Casio
      va chasser sur les terres de
      TI
      ;)
  • un même modèle peut désormais gérer jusqu'à un maximum de 4 modes examen différents
  • sur les modèles qui proposent plusieurs modes examens, le mode examen international historique ou mode examen 1 sur la
    fx-CG50
    est renommé en tant que mode examen pour le Baccalauréat International
  • le mode examen 2 de la
    fx-CG50
    est renommé en tant que mode examen pour le Royaume-Uni

Voici le détail des modes examens présents sur chaque modèle après la dernière mise à jour :
Graph 35+E II
Graph 75+E
Graph 90+E
fx-9860G AU+
fx-9860GIIs
fx-9860GIII
Graph 75/95
fx-9750GIII
fx-9860GII
fx-CG10/20
fx-CG50
France
Baccalauréat
international
Pays-Bas
Royaume-Uni
Texas
Total
1
1
2
2
4


Sur les modèles qui offrent plusieurs modes examens les combinaisons d'activation sont différentes. Dans ce cas le type de mode examen invoqué est désormais précisé à l'écran de confirmation.

Une deuxième confirmation est de plus demandée dans le cas où le mode examen invoqué ne convient pas au Baccalauréat International.


Une fois le mode examen activé, il reste quand même identifiable à tout moment par le drapeau clignotant en haut à droite de l'écran, ainsi que sur les modèles couleur par la bordure de l'écran qui utilise une couleur différente.

Voici ci-dessous résumé en un seul coup d'oeil tout ce qui concerne les désormais 5 modes examens de
Casio
:
France
Baccalauréat International
Pays-Bas
Royaume-Uni
Texas
Modèles
Graph 35+E II
Graph 75+E
Graph 90+E
fx-9750GIII
fx-9860GIIs
Graph 75/95
fx-9750GIII
fx-9860G AU+
fx-9860GII/GIII
fx-CG10/20/50
fx-9860GII
fx-CG10/20/50
fx-CG50
fx-9750GIII
fx-CG50
Activation
cos
7
cos
7
cos
7
8
,
1
+
÷
Drapeau
R
R
R
N
R
T
Bordure
Verte
Verte
Jaune
Magenta
Cyan
Calcul exact
irrationnels
Autorisé
Interdit
Autorisé
Interdit
Autorisé
Autorisé
Calcul
vectoriel
Interdit
Interdit
Interdit
Interdit
Autorisé
Interdit
Graphes
inégalités
Autorisé
Autorisé
Autorisé
Autorisé
Autorisé
Interdit
Appli intégrée
Programme
Autorisé
Interdit
Interdit
Interdit
Interdit
Interdit
Appli intégrée
Python
Autorisé
Interdit
Interdit
Interdit
Interdit
Interdit
Appli
additionnelle
officielle
Graphe 3D
Interdit
Interdit
Interdit
Interdit
Autorisé
Interdit
Autres applis
additionnelles
officielles
Interdit
Interdit
Interdit
Interdit
Interdit
Interdit
Applis
additionnelles
non officielles
Interdit
Interdit
Interdit
Interdit
Interdit
Interdit
Contenu
mémoire
préexistant
Interdit
Interdit
Interdit
Interdit
Interdit
Interdit




10) Modifications d'interfaces

Go to top

Même si c'est moins essentiel ici, terminons en regardant les modifications apportées aux menus et messages de l'interface, habitude que nous avons prise pour découvrir les nouveautés puisque
Casio
ne publie pas de
changelog
détaillé.

Sur
Graph 90+E
et
fx-CG50
, lorsque l'on réalise un
backup
de la calculatrice dans l'applicatio
Système
, nous avons un message d'alerte contre l'écrasement si l'opération a déjà été réalisée. En français sa formulation avait changé lors de la mise à jour
3.20
.
Avec la mise à jour
3.12
, les
fx-CG10
et
fx-CG20
passent à leur tour à la nouvelle formulation, rattrapant leur retard.

Autre rattrapage, en Italien la formulation
"Elemento aggiuntivo"
pour les applications additionnelles dans les applications
Mémoire
et
Système
avait été remplacée par
"Add-In"
sur
Graph 90+E
et
fx-CG50
lors de la mise à jour
3.30
, ce qui évitait d'avoir à l'abréger à toutes les sauces dans les différents messages et menus.
Avec la mise à jour
3.12
, les
fx-CG10
et
fx-CG20
profitent elles aussi désormais de cette nouvelle formulation.

De façon similaire, sur les
Graph 90+E
et
fx-CG50
dès la mise à jour
3.30
, une abrévation isolée avait été supprimée dans l'aide en ligne à l'activation du mode examen.
Avec la mise à jour
3.12
, même changement dorénavant sur les
fx-CG10
et
fx-CG20
.

Toujours dans l'aide en ligne au mode examen mais cette fois-ci en italien, la dernière mise à jour passe les mentions de restritions concernant la mémoire et les programmes au pluriel.


13172Petit bug d'interface, lorsque dans l'application
Système
on choisissait de supprimer les applications additionnelles, dans toutes les langes le messages d'avertissement mentionnait en anglais un
MAIN MENU
.
En effet c'était un héritage lors de l'adaptation pour l'écran couleur du système
Casio Graph
monochrome en 2012, le titre du menu principal n'étant pas traduit sur les modèles monochromes.
Les
Graph 90+E
et
fx-CG50
avaient enfin bénéficié d'une correction pertinente de ce message pour la mise à jour
3.40
, et avec la mise à jour
3.12
les
fx-CG10
et
fx-CG20
en bénéficient à leur tour.

13173Toujours sur ce même message, les
fx-CG10
et
fx-CG20
mentionnaient en anglais une application
SYSTEM
, héritage là encore des modèles monochromes où les noms d'applications ne sont pas traduits.
Si on peut certes deviner l'application dont il est question dans la plupart des langues, c'était moins évident en Italien où l'application
Système
s'appelle
Set-Up
.
Quoiqu'il en soit avec la mise à jour
3.12
le message est désormais correct dans toutes les langues.

Casio
fait visiblement attention au moindre petit détail d'intuitivité. ;)




11) Conclusion

Go to top

Une très belle mise à jour. La solution
Python
de
Casio
est maintenant intégralement disponible en mode examen, le constructeur semble être fort à l'écoute de sa communauté d'utilisateurs et avoir traité la moindre des critiques bienveillantes formulées lors de notre annonce de la version précédente. :D

Nous louons le soin méticuleux que
Casio
semble apporter au respect d'un standard
Python
préexistant avec les modules de tracé par coordonnées
matplotlib.pyplot
et tracé relatif
turtle
, évitant de réinventer la roue, et épargnant donc double travail aux élèves et enseignants ! :bj:
Un exemple à suivre ! ;)


Même si cela ne concerne pas la France pour le moment, nous sommes heureux de voir que les choses commencent à bouger niveau mode examen, que
Casio
a enfin accepté l'idée d'avoir plusieurs modes examens plutôt qu'un unique mode examen avec la somme des restrictions réclamées par chaque institution ou pays concerné.
Le mode examen de
Casio
a en effet le défaut
(du point de vue utilisateur en tous cas)
d'être le plus restrictif tous constructeurs confondus, allant même jusqu'à bloquer ses propres applications additionnelles officielles alors que de telles applications ou fonctionnalités équivalentes restent parfaitement disponibles chez les modes examens concurrents.
Nous apprécierions donc si le mode examen français de
Casio
pouvait également être affiné à son tour pour mieux coller aux seuls interdits réclamés par la réglementation
(infos personnelles préchargées)
, autorisant donc l'usage des applications additionnelles officielles
(
Conversions
sur
Graph 90E+
,
Graphe 3D
,
Physium
,
ProbSim
,
Géométrie
)
, voir même d'applications additionnelles tierces comme . ;)




12) Téléchargements et liens

Go to top

Téléchargements
:


Référence
:
https://www.planet-casio.com/Fr/forums/ ... t-350.html

Envie d'en découvrir davantage sur le nouveau
Python
?
Casio
vient d'annoncer plusieurs vidéoconférences traitant de cette dernière mise à jour :
  • Lundi 19 octobre 14h-14h45 : Python sur les calculatrices Graph 35+E II et Graph 90+E
  • Mardi 27 octobre 14h-14h45 : Les bibliothèques graphiques Python : Turtle & Matplotlib
Pour t'inscrire et participer, c'est par ici : https://www.casio-education.fr/formations-en-ligne/

Nouvelle clé USB d'émulation 2020 Casio Graph 90/35+E II

New postby critor » 17 Sep 2020, 12:55

Les logiciels
Casio Manager/Subscription
sont d'excellents émulateurs disponibles dans différentes éditions couvrant l'intégralité des derniers modèles de la marque :
fx-92+ Spéciale Collège
,
Graph 35+E II
,
Graph 90+E
et
fx-CP400+E
.

D'une conception méticuleuse, ils permettent aux enseignants :
  • de copier des ressources pour concevoir des documents
    (captures d'écran, séquences de touches...)
  • de guider collectivement une classe en vidéoprojection, dans sa recherche du problème du jour
Toutefois ces logiciels ne sont normalement pas gratuits. En théorie, pour pouvoir les utiliser au-delà d'une période d'essai de 90 jours, l'enseignant doit acheter un numéro de licence pour chacune des éditions qu'il souhaitait utiliser.
En pratique pour la France, les numéros de licence sont généreusement fournis gratuitement aux enseignants par
Casio
sur simple demande. :bj:

Mais il n'empêche que ces licences ne sont pas permanentes, expirant après 1 ou 3 ans selon le prix
(1 an pour celles offertes par
Casio France
)
, et sont alors à renouveler, ce qui nécessite donc de faire les démarches à temps.

Au-delà de ça, le plus embêtant dans le contexte scolaire est qu'une fois activées, ces licences sont liées à la machine alors utilisée lors de l'activation, et ne peuvent plus resservir à débloquer un émulateur
Casio Manager/Subscription
sur une autre machine.
Or les imprévus ne sont pas rares pour les enseignants utilisant les ordinateurs de l'établissement :
  • changement de salle exceptionnel ou définitif
  • panne/vol/remplacement de l'ordinateur de la salle de classe
Sans compter que l'utilisation nécessite l'installation du logiciel et donc des droits proches de l'administrateur, ce qui est rarement le cas.

Et les enseignants apportant et utilisant leur ordinateur portable personnel ne sont pas non plus à l'abri de ces derniers incidents.

1299412995Pour la rentrée 2019,
Casio France
nous apportait une toute nouvelle solution avec des émulateurs sur clé
USB
pour le confort des enseignants et par conséquent celui des élèves ! :bj:

La solution concernait les
fx-92+ Spéciale Collège
,
Graph 35+E II
et
Graph 90+E
.

Plus besoin de s'embêter à gérer des numéros de licence, plus besoin d'installation, il suffit juste de connecter la clé USB à l'ordinateur pour pouvoir de suite vidéoprojeter ! :bj:

1300013001Pour cette rentrée 2020,
Casio France
nous sort une toute nouvelle clé
USB
d'émulation.

Première chose qui saute aux yeux, une refonte totale du
design
, digne d'un vaisseau de
Star Trek
! :favorite:
Fini l'embout qui était bien souvent une des premières choses que l'on perdait, la clé désormais monolithique s'ouvre d'une simple pression et se referme automatiquement dès que retirée de l'ordinateur ! :bj:

La nouvelle clé annonce donc une capacité brute de
8 Go
. Ceux qui ont déjà vérifié savent qu'entre l'astuce commerciale d'entretenir la confusion entre les unités
Go
(109= 1000000000 octets)
et
Gio
(230= 1073741824 octets)
pour pouvoir annoncer ce qui arrange et l'espace réservé par le formatage du système de fichiers, en pratique on trouve toujours nettement moins. Par exemple, la clé de l'année dernière n'offrait que
7,5 Go
de capacité réelle.
Et bien bonne nouvelle, la clé
USB
de cette rentrée 2020 passe à
7,7 Go
de capacité réelle, de quoi stocker encore plus de scripts
Python
! :bj:

Enfin bien évidemment, la nouvelle clé vient directement préchargée des dernières versions des émulateurs avec l'ensemble des derniers ajouts
Python
dont le module de tracé par pixels
casioplot
, aucun besoin donc immédiat de la mettre à jour : :bj:
  • l'émulateur
    Graph 90+E
    passe de la version
    3.25
    à la version
    3.40
  • l'émulateur
    Graph 35+E II
    passe de la version
    3.10
    à la version
    3.30

En prime les émulateurs viennent même préchargés des modules
Python
officiels optionnels : :bj:
  • matplot
    , module de tracé par coordonnées, compatible avec le standard
    matplotl.pyplot
  • turtle
    , module de tracé à la tortue, compatible avec le standard du même nom

Si tu ne l'as toujours pas fait, nous te remettons ci-dessous de quoi mettre ton ancienne clé
USB
à jour.
Attention, ces émulateurs utilisent
EasyGuard
, une protection contre la copie. /!

Ils ne fonctionneront que si ils détectent la présence d'une clé
USB
d'émulation officielle de
Casio
, vérifiant dans le dossier racine la conformité d'un fichier de signature par rapport au numéro de série de la clé en question. :#non#:

Avec le nombre d'événements annulés cette année, tu risques ne ne pas avoir beaucoup d'occasions de récupérer cette clé
USB
d'émulation... :'(

Et bien réjouis-toi car nous allons t'en faire gagner très prochainement tout un stock à notre concours de rentrée ! :bj:


Téléchargements
:


Batterie externe USB Casio, extension pour ta calculatrice !

New postby critor » 13 Sep 2020, 13:55

1298612985Cette année comme chaque année
Casio
t'a conçu de tous nouveaux
goodies
. Voici donc ci-contre une des dernières créations du constructeur, une batterie
USB
externe estampillée à son nom.

Un goodies exceptionnel qui pour une fois n'ira pas ramasser la poussière sur ton étagère ou dormir au fond de ton tiroir mais saura se rendre utile, et qui plus est pourra être utilisé directement avec ta calculatrice ! :bj:
Et puis ce serait toute une fierté d'adjoindre ça à ta
Casio
, non ? ;)

1298812990Il s'agit en fait de la , un objet publicitaire personnalisable distribué en Europe par
Inspirion
.

La batterie offre une capacité de
2200 mAh
.

12989Nous disposons donc d'un port
USB micro-B
pour la recharge, ainsi que d'un port
USB A
pour alimenter ta calculatrice ou tout autre appareil compatible.

Une fois chargée et connectée au port
USB
de ta calculatrice, la batterie externe te permet selon les modèles :
  • d'alimenter ta calculatrice et donc de prolonger la durée de vie de ses piles ou de sa batterie interne
  • de recharger la batterie interne de ta calculatrice

12991Avec la
Graph 35+E II
et autres calculatrices
Casio Graph
monochromes c'est particulièrement impressionnant, puisque la calculatrice accepte parfaitement de s'allumer et continuer à fonctionner correctement alimentée par la seule batterie externe, piles internes retirées donc ! :bj:
Tu pourras donc même continuer à utiliser ta calculatrice une fois les piles complètement déchargées ! :D
Attention toutefois, piqûre de rappel, en tant que module externe cette batterie
USB
est strictement interdite d'utilisation aux examens en France. :#non#:


La batterie externe
USB Casio
n'étant pas sectaire, voici d'autres modèles qui s'accomodent parfaitement de cette seule alimentation externe : :bj:
  • TI-Nspire CX
  • HP Prime

Les modèles
Casio
couleur
Graph 90+E
et
fx-CP400+E
quant à eux n'acceptent pas de fonctionner en l'absence de l'alimentation interne par piles. Malgré l'alimentation externe, la calculatrice s'allume puis s'éteint immédiatement. Soit l'alimentation externe est insuffisante ce qui serait quand même surprenant vu les deux derniers modèles testés, soit ces modèles sont tout simplement plus stricts dans leurs vérifications de l'alimentation interne.

Le reste des modèles testés refuse catégoriquement de s'allumer lorsque alimentés uniquement en externe via leur port
USB
:
  • TI-83 Premium CE
  • TI-82 Advanced
  • NumWorks
  • TI-Nspire
    monochromes

Avec le nombre d'événements annulés cette année, tu risques ne ne pas avoir beaucoup d'occasions de récupérer ce
goodies
d'exception... :'(

Et bien réjouis-toi car nous allons t'en faire gagner très prochainement tout un stock à notre concours de rentrée ; il y en aura pour récompenser tous les gagnants optant pour un lot
Casio
! :bj:

Test-découverte Casio Graph 25+E II version 3.20 rentrée2020

New postby critor » 26 Aug 2020, 14:32

120881208711072Pour cette rentrée 2020
Casio
termine la migration de ses calculatrices graphiques monochromes vers la nouvelle génération technologique
USB Power Graphic 3
.

Au menu un
relooking
complet du boîtier ainsi qu'une refonte majeure du matériel : processeur 2 fois plus rapide passant de
29,5 MHz
à
59 MHz
, doublement de la capacité
Flash
de
4 Mio
à
8 Mio
, ce qui double également la mémoire de stockage de
1,5 Mio
à
3 Mio
, nouveau contrôleur écran, ... mais également des nouveautés logicielles avec une nouvelle application
Python
, l'ajout de l'Italien dans le choix des langues ainsi que des
QR Code
d'aide associés aux commandes listées au catalogue.

Casio
avait offert la primeur de la nouveauté à la France dès la rentrée 2019 avec la
Graph 35+E II
remplaçant les
Graph 35+E
et
Graph 75+E
. Le reste des gammes française et internationale suit donc pour cette rentrée 2020 avec :
  • remplacement de la
    fx-9860GII
    (similaire à l'ancienne
    Graph 75+E
    )
    par la
    fx-9750GIII
    ou
    fx-9860GIII
    selon les pays
  • remplacement de la
    fx-9750GII
    (similaire à l'ancienne
    Graph 35+E
    )
    par la
    fx-9750GIII
    ou
    fx-9860GIII
    selon les pays
  • remplacement de la
    fx-7400GII
    (similaire à la
    Graph 25+E
    )
    par la
    fx-7400GIII
  • remplacement de la
    Graph 25+E
    par la
    Graph 25+E II

Voici une petite table rapide pour y voir plus clair dans les équivalences selon les générations et zones géographiques :
France
Amérique
du Nord
gamme
internationale
USB Power Graphic 2
Graph 25+E

Graph 35+E

Graph 75+E
fx-7400GII

fx-9750GII

fx-9860GII
USB Power Graphic 3
Graph 25+E II

Graph 35+E II
fx-7400GIII

fx-9750GIII
fx-7400GIII

fx-9860GIII

La nouvelle
Graph 25+E II
est donc à son tour le grand événement de cette rentrée 2020 ; voyons donc sans plus attendre ce qu'elle vaut.








1) Déballage :

Go to top

1258012581Voici donc ci-contre la
Graph 25+E II
, la nouveauté de la rentrée 2020.

Comme indiqué il s'agit donc d'un modèle conforme avec le mode examen qui sera
normalement
inauguré à la session d'examens 2021.

1257212575L'emballage contient la calculatrice, son couvercle coulissant, ainsi qu'un pack d'accessoires.

Le pack d'accessoires en question renferme :
  • un guide de prise en main rapide commun aux
    Graph 25+E II
    et
    Graph 35+E II
  • la carte de garantie
  • un câble
    mini-Jack 2.5mm
    pour transfert de données entre calculatrices
  • 4 piles
    AAA
    neuves de chez
    Panasonic

1260612605Revenons donc à la calculatrice
Graph 25+E II
, qui reprend donc le nouveau boîtier
Graph 35+E II
à une différence de coloris près.

Nous bénéficions donc du nouveau couvercle pouvant être glissé sur la calculatrice aussi bien par en haut que par en bas, pour un total de 4 positions possibles.

Le coloris de l'ancienne
Graph 25+E
pouvait être vu comme une inversion des couleurs de la
Graph 35+E
, avec d'une part le couvercle et la face arrière, et d'autre part la face avant. C'est visiblement ce même principe qui est repris et nous donne ici le coloris de la
Graph 25+E II
.

Les modèles d'entrée de gamme
Graph 25
sont historiquement des versions matériellement et logiciellement allégées des
Graph 35
. Nous allons voir de suite si c'est toujours le cas avec la
Graph 25+E II
.

125781257712579Notons la superbe rosace gravée au verso comme sur
Graph 35+E II
, décidément la signature de la génération
USB Power Graphic 3
, l'occasion de belles discussions avec ton enseignant de Mathématiques à la rentrée ! ;)




2) Ecran et connectivité :

Go to top

1258512582Nous disposons donc ici d'écran large de 128×64 pixels, fort agréablement dimensionné. Toutefois, l'ancienne
Graph 25+E
présentait un écran nettement inférieur à celui de la
Graph 35+E
. L'écran était un peu plus petit et de plus utilisait des cristaux liquides bleus au lieu de noirs. Beaucoup moins contrasté, la lisibilité en était donc assez mauvaise.

Et bien excellente nouvelle,
Casio
met fin à cette pratique. Le nouveau modèle d'entrée de gamme
Graph 25+E II
dispose désormais du même superbe écran monochrome que le milieu de gamme
Graph 35+E II
; c'est-à-dire un écran aussi grand et surtout correctement contrasté à la lisibilité donc excellente ! :bj:

1259212603Un autre allègement matériel touchait la connectivité. L'ancienne
Graph 25+E
était dépourvue du port
mini-USB
présent sur le reste de la gamme
USB Power Graphic 2
, et ici c'est par contre toujours le cas sur la
Graph 25+E II
.

D'origine donc, note bien que tu n'auras aucune connexion directe à l'ordinateur. Pour charger tes données il te faudra soit les transférer depuis une autre calculatrice
Casio Graph
, soit les taper à la main.

3718Pour la communication avec un ordinateur il te faudra acquérir séparément une interface ou compatible. L'interface officielle est difficile à trouver en neuf, actuellement en rupture de stock chez le distributeur
TS Promotion
depuis plusieurs années.

Une interface parfaitement compatible est disponible pour un peu moins cher chez le français
Util-Pocket
.

Note bien que dans les deux cas, en additionnant les prix de la
Graph 25+E II
et de l'interface, tu vas atteindre et même dépasser le coût d'une
Graph 35+E II
munie d'origine d'un port mini-USB et ne nécessitant donc aucune interface, sans compter les fonctionnalités bien plus étendues. Donc autant acheter directement une
Graph 35+E II
, non ? ;)

La communication est contrôlée ensuite côté ordinateur via le logiciel
Casio FA-124
.

FA-124
permettait alors de transférer des fichiers, et d'effectuer des captures d'écran.

Pour les captures d'écran à réaliser avec
SHIFT
7
sur les
Casio Graph
, 2 modes sont configurables à l'aide de la touche
F6
dans l'application
Link
:
  • Mémoire
    : La capture d'écran est stockée dans la mémoire de la calculatrice, pour un maximum de 20 captures d'écran. Il faut donc ensuite transférer manuellement le fichier en question avec
    FA-124
    , et le convertir en un format d'image plus standard.
  • ScreenCapture
    : La capture d'écran est envoyée automatiquement vers
    FA-124
    où l'on obtient un affichage qui peut être directement copié-collé.

Ces deux modes de capture d'écran étaient encore disponibles sur l'ancienne
Graph 25+E
. Toutefois, pour une raison que nous ignorons, le mode
ScreenCapture
a été supprimé sur
Graph 25+E II
. Plus rien n'est donc configurable, et exploiter une capture d'écran spécifique à ce modèle va donc être compliqué. :'(




3) Applications intégrées :

Go to top

Le caractère d'entrée de gamme de l'ancienne
Graph 25+E
était très loin de se limiter au matériel. Logiciellement nous n'avions également que 9 applications accessibles au menu principal, nettement moins que sur le reste de la gamme
USB Power Graphic 2
:
Graph 25+E
fx-7400GII
fx-7400GIII
Graph 35+E

(version
2.05-2.09
)

fx-9750GII
Graph 35+E

(version
2.10
)
Graph 75+E
fx-9860GII
Graph 35+E II
fx-9750GIII
fx-9860GIII
RUN

Image
STAT

Image

Image

Image
GRAPH

Image

Image
TABLE

Image

Image

Image
EQUA

Image
PRGM

Image

Image

Image
LINK

Image
MEMORY

Image
SYSTEM

Image

Image
RUN·MAT

Image
STAT

Image

Image

Image
GRAPH

Image
DYNA

Image
TABLE

Image
RECUR

Image
CONICS

Image
EQUA

Image
PRGM

Image
TVM

Image
E·CON2

Image
LINK

Image
MEMORY

Image
SYSTEM

Image

Image
RUN·MAT

Image
STAT

Image

Image
S·SHT

Image
GRAPH

Image
DYNA

Image
TABLE

Image
RECUR

Image
CONICS

Image
EQUA

Image
PRGM

Image
TVM

Image
E·CON2

Image
LINK

Image
MEMORY

Image
SYSTEM

Image

Image
RUN·MAT

Image
STAT

Image
e·ACT

Image
S·SHT

Image
GRAPH

Image
DYNA

Image
TABLE

Image
RECUR

Image
CONICS

Image
EQUA

Image
PRGM

Image
TVM

Image
E·CON3

Image
LINK

Image
MEMORY

Image
SYSTEM

Image

Image
RUN·MAT

Image
STAT

Image
e·ACT

Image
S·SHT

Image
GRAPH

Image
DYNA

Image
TABLE

Image
RECUR

Image
CONICS

Image
EQUA

Image
PRGM

Image
TVM

Image
E·CON3

Image
LINK

Image
MEMORY

Image
SYSTEM

Image
PYTHON

Image
9
apps
14
apps
15
apps
16
apps
17
apps

Aucun progrès sur
Graph 25+E II
, nous continuons à ne bénéficier que de ces mêmes 9 applications :
  1. RUN
  2. STAT
  3. GRAPH
  4. TABLE
  5. EQUA
  6. PRGM
  7. LINK
  8. MEMORY
  9. SYSTEM
Toutefois le caractère d'entrée de gamme de l'ancienne
Graph 25+E
était loin de se limiter au seul nombre d'applications disponibles. Nous allons donc voir si les applications concernées ont été améliorées.




4) Application RUN, calcul et menu TEST MODE :

Go to top

L'application de calcul de l'ancienne
Graph 25+E
s'appelle
RUN
et non pas
RUN·MAT
comme sur les modèles supérieurs. C'est en effet qu'elle ne gère ni les matrices ni les vecteurs.

C'est très loin d'être la seule limitation. Pas de possibilité de remonter dans l'historique de calcul affiché avec
pour réutiliser une saisie ou résultat précédent, nous ne pouvons ici manipuler que le dernier résultat ou saisie.

Pas de calcul exact
QPiRac
, ici seules les fractions sont gérées.

Et aucune saisie ou affichage en écriture naturelle, nous n'avons droit qu'à des affichages en ligne pas toujours agréables à lire, et à des saisies en ligne à parenthéser correctement pour éviter les erreurs.

Toutes ces limitations semblent hélas toujours présentes sur
Graph 25+E II
, et le choix de ce modèle à la rentrée au lycée sera donc un douloureux retour en arrière par rapport à une
TI/Casio Collège
.

86068601Toutefois, sur l'ancien modèle
Graph 25+E
, il existait un menu secret
TEST MODE
appelable de la façon suivante :
  • Eteindre la calculatrice avec
    SHIFT
    AC/ON
    .
  • Maintenir enfoncées simultanément les touches
    OPTN
    x10^x
    .
  • Sans relâcher ces 2 touches, allumer la calculatrice avec
    AC/ON
    .
    On obtient alors une boîte
    DIAGNOSTIC MODE
    .
  • Relâcher toutes les touches.
  • Taper alors successivement le code secret
    5
    9
    6
    3
Dans le menu
TEST MODE
alors obtenu, on pouvait activer la saisie et l'affichage en écriture naturelle et ce de façon persistante, même en mode examen.

12600Hélas,
Casio
semble avoir supprimé cet accès au menu
TEST MODE
sur
Graph 25+E II
. La combinaison
5
9
6
3
ne fait désormais que quitter la boîte
DIAGNOSTIC MODE
, et il n'est donc plus possible d'activer l'écriture naturelle.
Une régression ici majeure de fonctionnalité. :mj:




5) Application STAT, probabilités et échantillonnage :

Go to top

Sur l'ancienne
Graph 25+E
, l'application
STAT
était dépouillée de plusieurs menus de bas d'écran et donc fonctionnalités présentes sur le reste de la gamme
USB Power Graphic 2
:
  • distributions de probabilités
    (lois binomiale, normale, ...)
  • échantillonnage avec tests de prise de décision et intervalles de fluctuation/confiance
Pas d'amélioration ici sur la
Graph 25+E II
.




6) Application MEMORY et mémoire :

Go to top

Contrairement au reste de la gamme
USB Power Graphic 2
, l'application
MEMORY
de l'ancienne
Graph 25+E
ne donnait accès qu'à un seul espace dit
Mémoire principale
. Il s'agit d'un espace de stockage pris sur la mémoire
RAM
, et enregistré en mémoire
Flash
à chaque extinction de la calculatrice.

De plus, la capacité n'en était pas de
62 Ko
mais seulement
20 Ko
, un bridage volontaire puisque le matériel était identique.

Pour le matériel nous verrons plus tard, mais en tous cas pas d'amélioration avec la
Graph 25+E II
qui continue à n'offrir que
20 Ko
d'espace de stockage
RAM
pour les variables.

Aucune trace d'un espace de stockage
Flash
. Sur l'ancienne
Graph 25+E
cela se comprenait, puisque la mémoire
Flash
faisait
2 Mio
et était presque entièrement occupée par le système d'exploitation, ne permettant donc aucun ajout d'application.
Comme ses sœurs de la gamme
USB Power Graphic 3
, la
Graph 25+E II
bénéficie-t-elle d'une puce
Flash
de capacité supérieure qui nous permettrait d'espérer un jour des mises à jour ou astuces intéressantes en ce sens ou pas ? Nous verrons également cela plus loin. ;)




7) Application PRGM, processeur et performances :

Go to top

Traitons maintenant de l'aspect programmable de la machine et surtout de ses performances. A cette fin, prenons le script
Python
qui a servi de support de test au
QCC 2019
:
Code: Select all
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed,n=hastime(),0
  start,u=0 or timed and monotonic(),2.
  d=d**2
  while (u-1)**2>=d:
    u=1+1/((1-u)*(n+1))
    n=n+1
  return [(timed and monotonic() or 1)-start,n,u]


Nous allons ici chronométrer le temps que met un appel seuil(0.008).
Mais, il n'y a pas d'application
Python
comme clairement indiqué au dos de l'emballage. Et vu la haute ressemblance avec la
Graph 35+E II
tu devras donc faire très attention à ne pas te tromper dans ton achat. :#non#:


Traduisons donc dans le langage historique de la machine :
Code: Select all
?→D
0→N
2→U
D^2→D
While (U-1)^2≥D
  1+1÷((1-U)*(N+1))→U
  N+1→N
WhileEnd
{N,U}


Nous chronométrons donc ici avant réponse
1min 13,5s
, soit très légèrement plus rapide que la
Graph 35+E II
.
Mais peut-être que la différence est due ici à l'absence de gestion du calcul exact et nous pouvons donc conjecturer exactement le même processeur 32 bits : un
SH4
cadencé à
58,98 MHz
.

Voici ce que ça donne avec les autres modèles, même programme traduit dans le langage historique de chaque machine et exécuté hors de tout contexte numérique exact ou formel :
  1. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  2. 0,688s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  3. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  4. 2,41s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  5. 8,93s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  6. 12,24s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    )
  7. 18,94s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    )
  8. 20,92s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    )
  9. 50,77s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  10. 73,50s
    :
    Casio Graph 25+E II
    (32 bits : SH4 @
    58,98MHz
    )
  11. 81,03s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  12. 101,1s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @
    29,49MHz
    )
  13. 117,29s
    :
    Casio Graph 25+E
    (32 bits : SH4 @
    29,49MHz
    )
  14. 120,51s
    :
    TI-83 Premium CE Edition Python
    /
    TI-84 Plus CE-T Python Edition
    /
    TI-84 Plus CE
    (révisions M-O)
    (8 bits : eZ80 @
    48MHz
    )
  15. 196,79s
    :
    TI-83 Premium CE
    /
    TI-84 Plus CE
    (révisions A-L)
    (8 bits : eZ80 @
    48MHz
    )
  16. 260,41s
    :
    TI-82 Advanced
    /
    TI-84 Plus T
    (8 bits : z80 @
    15MHz
    )
  17. 607,91s
    :
    Casio fx-CP400+E
    (32 bits : SH4 @
    117,96MHz
    )
  18. 672,65s
    :
    Casio fx-92+ Spéciale Collège
    (8 bits : nX-U8/100 >
    1,5MHz
    - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
  19. 798,18s
    :
    Esquisse GCEXFR
    /
    Lexibook GC3000FR
    (non programmable, estimation relative par comparaison des performances en tracé de graphes avec le modèle le plus proche technologiquement, la
    TI-82 Advanced
    )

Et si l'on ne retient que les dernières révisions matérielles de chaque modèle, voici les performances proportionnelles de chacun :


Malgré ses caractère et prix d'entrée de gamme la
Graph 25+E II
s'en tire honorablement niveau performances, se classant dans la moitié supérieure ! :bj:




8) Application SYSTEM, versions et langues :

Go to top

12896La
Graph 25+E II
vient donc préchargée d'une version système
3.20
.

Le suffixe
.2700
ne fait pas partie du numéro de version et est purement informatif.

Le chiffre des milliers par exemple est en fait le code de zonage, lu directement en mémoire
Flash
. Pour rappel,
Casio
utilise les valeurs suivantes :
  1. Australie
  2. France
  3. Amérique du Nord
  4. Chine
  5. Singapour
Le zonage détecté affecte plusieurs fonctionnalités. Par exemple le zonage 2
(
fx-CP400+E
)
autorise la création de programmes en mode examen, alors que ce n'est pas le cas pour le reste du monde.

Le chiffre des centaines indique les capacités liées à l'application de calcul
RUN
, et peut ainsi être vérifié par les surveillants dans les pays qui ont des examens interdisant notamment le calcul exact, ce qui n'est pas le cas en France :
  • 2 :
    calcul exact
    QPiRac
    automatique + écriture naturelle
  • 1 / 3 :
    calcul exact
    Q
    automatique + écriture naturelle
  • 7 :
    calcul exact
    Q
    manuel

Notons également les langues qui passent de façon similaire en version
3.20
; il doit donc y avoir de petits changements quelque part. ;)

12895Une grande nouveauté de la génération
USB Power Graphic 3
était l'ajout d'une 6ème langue, l'Italien.

Or nous pouvons remarquer ici que contrairement à ses sœurs dont la
Graph 35+E II
, la
Graph 25+E II
ne bénéficie pas de cette amélioration, restant donc sur les 5 langues historiques :
  • English
    (Anglais)
  • Español
    (Espagnol)
  • Deutsch
    (Allemand)
  • Français
  • Português
    (Portugais)
Assez curieux que nous n'ayons donc pas l'Italien, et en fait c'est un assez mauvais signe. Additionné à l'absence totale d'évolution des applications dénoncée précédemment, se pourrait-il que la
Graph 25+E II
continue à utiliser une puce
Flash
de
2 Mio
? Cela expliquerait tout, l'Italien n'y rentrait tout simplement pas... :#roll#:




9) Mode examen :

Go to top

Avant de répondre aux dernières interrogations que nous avons sur la
Graph 25+E II
, petit détour par son mode examen.

Ah ben voilà, justement, l'aide intégrée au mode examen accessible via
F3
sous l'application
LINK
a fait l'objet de plusieurs reformulations :
129031290412905129061290712908


12595Le mode examen allume donc une diode rouge très lumineuse sur la tranche supérieure de la calculatrice.

Le couvercle de la
Graph 25+E II
a de plus le gros avantage d'être échancré à ses deux extrémités. Plus possible donc de s'en servir pour masquer la diode examen, et donc dissimuler en début d'épreuve le fait qu'une calculatrice est déjà en mode examen donc par extension non vide de données personnelles. :#non#:

Attention toutefois, comme pour l'ancienne
Graph 25+E
le mode examen de la
Graph 25+E II
est extrêmement difficile à désactiver. Or, tu ne pourras pas utiliser ta calculatrice à une épreuve si tu te présentes avec un mode examen déjà activé. :#non#:

Sans l'interface , tu ne pourras pas désactiver le mode examen de ta calculatrice avec un ordinateur.
Ta seule est unique possibilité est donc la désactivation par connexion à une autre calculatrice
Casio Graph
compatible.

Sauf qu'énorme inconvénient chez
Casio
, l'autre calculatrice en question ne doit pas être en mode examen sinon ça ne marchera pas. /!

Et voilà le problème, quand tu sortiras de ton épreuve les
Casio Graph
de tes camarades seront forcément toutes en mode examen, et aucun ne pourra donc t'aider à désactiver ton mode examen. :#non#:
Quand tu rentreras chez toi tu ne pourras pas non plus désactiver le mode examen avec ton ordinateur. :#non#:

Ta seule et unique possibilité sera de demander de l'aide à un camarade équipé d'une
Casio Graph
un autre jour, lors de la prochaine épreuve nécessitant le mode examen. Cela implique donc de ne pas oublier et de t'y présenter suffisamment à l'avance. /!
Attention, les conséquences de tout oubli peuvent être dramatiques, officiellement tu devras composer sans calculatrice si tu arrives à ton épreuve avec un mode examen déjà activé et qu'il t'est impossible de le désactiver ! :mj:




10) Menu de diagnostic et Boot :

Go to top

125931258912588Bon finissons-en, il est temps d'arracher ses derniers secrets à la
Graph 25+E II
. Accédons au menu caché de diagnostic. Il suffit pour cela d'allumer la calculatrice tout en maintenant les touches
OPTN
et
×10^x
, puis de taper
F1
9
.

Nous y découvrons la référence de la
Graph 25+E II
,
CY836A
.

Les
Q-bits
(bits de drapeau)
permettant d'identifier entre autre le zonage de la calculatrice sont ici réglés à
010
, sans surprise comme sur
Graph 35+E II
.

12594Le menu
4.VERSION
nous indique que le système d'exploitation
3.20
préchargé sur la
Graph 25+E II
a été compilé le
7 novembre 2019
à
17h03
.

Nous y apprenons également que le
Boot Code
a pour sa part été compilé le
16 octobre 2018
à
12h01
, exactement comme celui de la
Graph 35+E II
. On pourrait donc se demander légitimement si
Graph 25+E II
et
Graph 35+E II
partageraient le même
Boot Code
.

12597Il semble en fait que non, le menu
+.VER&SUM
nous indique pour le
Boot Code
des sommes de contrôle qui diffèrent entre ces deux modèles.




11) Matériel :

Go to top

1260111096Et enfin, il est grand temps de vérifier ce que la
Graph 25+E II
a dans le ventre :bat: , et de comparer à la
Graph 35+E II
.

Graph 25+E II
et
Graph 35+E II
utilisent les mêmes cartes électroniques :
  • carte d'alimentation
    PWB-CY835-E4
  • carte mère
    PWB-CY835-1

Différence essentielle donc entre
Graph 25+E II
et
Graph 35+E II
, le port
mini-USB
n'est pas soudé sur la carte de la
Graph 25+E II
.
Toutefois l'emplacement est bien présent, et il est donc en théorie possible de le rajouter. Toutefois quelques composants avoisinants sont également manquants, ce qui ne facilite pas la tâche.

Autre différence, il ne semble pas y avoir de mise à la masse pour l'écran de la
Graph 25+E II
. Peut-être l'écran est-il différent même si nous n'avons rien remarqué en ce sens jusqu'à présent, ou peut-être
Casio
a-t-il tout simplement changé ça.

Dernière différence et non des moindres, la puce
Flash
est ici une
EN29LV160C
de chez
Elite
, et comme on pouvait s'en douter ne fait que
2 Mio
de capacité.
Voilà pourquoi il n'y a aucune nouvelle appli ou fonctionnalité sur
Graph 25+E II
, voilà pourquoi l'Italien n'a pas été rajouté, on reste avec la même capacité
Flash
que sur l'ancien modèle
Graph 25+E
et qui était déjà pleine à craquer, rien de plus ne pouvait rentrer. :(
Cela suggère aussi que la
Graph 25+E II
va rester en l'état, le constructeur n'a aucune intention de faire des ajouts ultérieurement via des mises à jour.

126015201Comparons maintenant la
Graph 25+E II
à l'ancienne
Graph 25+E
.

Autre changement d'importance, la diode examen a été sécurisée. :bj:
Elle n'est plus déportée sur une carte fille mais intégrée directement en CMS à la carte mère, les bricoleurs du dimanche auront beaucoup plus de mal à la trafiquer. :#non#:




Conclusion :

Go to top

12909Par rapport à l'ancienne
Graph 25+E
, la
Graph 25+E II
est à notre avis un rafraîchissement réussi de l'entrée de gamme. :bj:

Nous déplorons certes le blocage de l'astuce qui permettait d'activer l'écriture naturelle.
Mais nous pensons que le nouvel écran nettement supérieur ainsi que le processeur deux fois plus rapide profiteront à bien davantage d'utilisateurs.

Il n'en reste pas moins que la
Graph 25+E II
est un modèle d'entrée de gamme extrêmement bridé dont nous déconseillons l'achat :
  • pas de calcul exact ni d'écriture naturelle, c'est un retour en arrière très pénalisant par rapport à ta
    Casio/TI Collège
    :mj:
  • pas de suites récurrentes ou de lois de probabilités, thèmes pourtant essentiels à partir de la Première dans l'ensemble des parcours Mathématiques du lycée :mj:
  • pire pas de
    Python
    , langage transversal à l'ensemble des enseignements scientifiques au lycée :mj:
  • pas de connectivité USB :mj:
  • mode examen très difficile à désactiver :mj:
A notre avis tu ferais largement mieux d'opter pour la
Graph 35+E II
très supérieure. Même si ton enseignant commet l'erreur de recommander la
Graph 25+E II
tu n'auras strictement aucun problème à suivre avec une
Graph 35+E II
, tu y retrouveras exactement les mêmes claviers et menus ! :D
De plus pour cette rentrée 2020 tu pourras peut-être même trouver la
Graph 35+E II
pour moins cher que la
Graph 25+E II
, grâce aux formidables offres de
Casio
:
  • 10€
    remboursés
    pour tout achat à neuf d'ici le
    30 septembre 2020
    :bj:
  • +8€
    si tu renvoies ton ancienne
    fx-92 Collège
    , aux frais du constructeur :bj:
Après nous connaissons le contexte sanitaire et économique difficile, et nous sommes reconnaissants à
Casio
d'opposer une
Graph 25+E II
d'entrée de gamme et donc abordable tout l'année pas si mal que ça, face aux monstruosités disponibles chez et .

Oiram CE renaît sur Casio Graph 90+E / fx-CG10/20/50

New postby critor » 25 Aug 2020, 11:04

Grâce à la formidable ludothèque que sa communauté a su lui concocter depuis 2015, la
TI-83 Premium CE
est rapidement devenue la calculatrice couleur n°1 au lycée français. Une calculatrice cool et appréciée de ses utilisateurs, tout contents d'avoir à la fois un compagnon de travail, de réussite et de divertissement. :bj:

Avec plus de 108000 téléchargements,
Oiram CE
est chez nous le 2ème jeu le plus populaire pour
TI-83 Premium CE
, et également le 2ème fichier le plus téléchargé pour calculatrices. Publié en
janvier 2017
par , il s'agit d'un moteur de jeu
Mario-like
aux
sprites
et
gameplay
très inspirés de
Super Mario Bros 3
.
De plus
Oiram CE
accepte des packs de niveaux pouvant être créés de façon totalement intuitive grâce à un éditeur, c'est toute une sous-communauté qui s'est formée au sein de la communauté avec à ce jour plus de 80 packs de niveaux perso ! :favorite:

La création de jeux de qualité professionnelle dans le genre d'
Oiram
ne se fait pas en
Python
mais en langage machine vulgairement appelé assembleur dans la communauté, un langage accessible officiellement depuis 1996 sur les calculatrices
Texas Instruments
. Ces jeux sont compilés sur-mesure vers le langage machine de la calculatrice, à partir de code source écrit en langage
C
ou assembleur.

Hélas, avec la mise à jour
5.5
,
Texas Instruments
a brutalement décidé de sonner la fin de la récré. Toute installation d'une version
5.5
ou supérieure bloquera la capacité de la machine à exécuter des programmes en langage machine. Et bien évidemment, une fois une telle version installée c'est définitif, une inscription dans une zone non réinitialisable de ta machine refusera toute installation ultérieure d'une version inférieure.

La gestion des programmes en langage machine sur les calculatrices
Texas Instruments
vient donc d'être placée en voie d'extinction, un coup dur pour la communauté avec une grande part des fichiers servis gratuitement sur Internet désormais inutilisables. Des 100aines de jeux jetés aux oubliettes de l'histoire, des 10aines de niveaux perso bons pour la poubelle, des 1000iers d'heures de travail de passionnés parties en fumée, le tout bien évidemment sans aucune discussion préalable ! :mj:

Il sera désormais énormément plus difficile sinon impossible de concevoir des créations de qualité professionnelle pour
TI-83 Premium CE
, seul le constructeur le pourra, et uniquement quand il en aura envie. :'(

Nous n'avons aucune raison de te cacher la vérité, selon l'assemblage des éléments que nous avons cette décision découle de la lourde irresponsabilité d'un enseignant-vidéaste français très populaire qui, avec une vidéo anxiogène induisant en erreur sur certaines choses et trop complète sur d'autres, a de par sa visibilité gravement mis en danger le déroulement des épreuves d'examens
('heureusement' annulées cette année 2020 vu le contexte sanitaire)
ainsi que l'image de
Texas Instruments
auprès des institutions réglementant ces mêmes examens. Pour le constructeur il s'agissait donc d'envoyer un signal fort aux institutions en question, quitte à taper sur des innocents n'ayant pourtant strictement rien à voir avec l'incident initial. :mj:

La communication du constructeur diffère bien évidemment de cela, car oui pour les utilisateurs qui téléchargent leurs mises à jour sur le site officiel l'information est bel et bien présente au sein d'un paragraphe sur les pages en question, un paragraphe peut-être un peu trop long vu le public ciblé, pouvant de plus être pris de par sa position comme un résumé des contrats de licence de logiciels que pas grand monde ne lit :
TI wrote:Chez TI, nous travaillons constamment sur des moyens d'améliorer nos produits pour donner aux étudiants plus d'occasions d'apprendre, d'explorer et d'étudier les mathématiques et les sciences. Après un examen attentif, nous avons pris la décision de supprimer la fonctionnalité ASM dans notre dernière mise à jour du système d'exploitation pour prioriser l'apprentissage et minimiser les risques de sécurité. Nous pensons que cela aidera également les élèves à se concentrer sur l'apprentissage des mathématiques et des sciences. Une fois que vous aurez mis à jour la version 5.5 du système d'exploitation pour la TI-83 Premium CE, vous ne pourrez pas passer à une version antérieure.


Nous ignorons la part de vérité là-dedans, peut-être s'agit-il juste d'une façon de présenter la chose tout en s'assurant l'approbation et la sympathie de certains enseignants.

Nous ignorons si il y a vraiment des enseignants psychorigides qui ont été capables de se plaindre d'avoir des élèves qui jouent sur leur
TI-83 Premium CE
. Car si c'est le cas, enseignants concernés et constructeurs vont totalement à l'encontre des nouveaux programmes du collège qui préconisent de concevoir des jeux, et donc par extension des nouveaux programmes du lycée. :mj:

De nos jours où le
smartphone
est de plus en plus discret et difficile à interdire, il vaut largement mieux que la soupape de sécurité soit la calculatrice plutôt que le smartphone.

Sur smartphone la gratuité des applis n'est bien souvent qu'apparente, bombardant l'utilisateur de publicités pour l'amener à micro-consommer au sein de l'appli ou même consommer tout court. Et imaginez jusqu'où peuvent aller les responsabilités si une transaction finalement pas si micro que ça est enregistrée sur un horaire de cours...
Sur calculatrices il n'y a rien de tout ça, nous avions un environnement totalement sain. Cela faisait trois décennies que des générations de passionnés se relayaient à partager leurs créations totalement gratuites.

Sur smartphone la quasi totalité des applis enferment l'utilisateur dans son rôle de simple utilisateur ou pire consommateur, aucune possibilité de contribuer.
Sur calculatrices nous nous battions sans relâche et avec succès depuis des années pour que le code source des créations soit disponible sous licence ouverte, permettant à l'utilisateur une fois le jeu pris en main de franchir le pas vers un rôle plus actif de créateur ou développeur, pouvant consulter le code source pour le comprendre, s'en inspirer ou le réutiliser.

A vouloir tout contrôler on finit par ne plus rien contrôler. Et si il est impossible d'interrompre l'écoulement d'une rivière, on peut par contre facilement en dévier le cours. ;)


Il n'y a pas à s'inquiéter d'avoir un élève en situation de réussite différée qui joue sur sa calculatrice. Contrairement au smartphone où la marche à franchir est bien plus haute, il y a, enfin avait, la chance extraordinaire de pouvoir s'appuyer sur son intérêt pour l'amener à comprendre le fonctionnement de son jeu, les algorithmes mathématiques qu'il y a derrière, et l'amener progressivement vers un rôle plus actif de créateur et donc vers la réussite, conformément aux programmes scolaires.
Il y a différentes façons d'arriver à la réussite sinon les marchés du périscolaire et soutien scolaire n'existeraient pas ; nous déplorons que notre valeur ajoutée, contribuée de façon totalement bénévole et désintéressée depuis des années, ait pu être niée à ce point. :'(

Et justement sèche tes larmes, grâce à l'ouverture du code source,
Oiram CE
n'est pas mort.
Thomas Williamson
vient en effet de le porter pour calculatrices
Casio
couleur
Graph 90+E
et
fx-CG10/20/50
, avec l'aide et la bénédiction de ! :bj:

Le temps de te laisser quelques secondes pour assimiler tout ce que cela implique, notons une icône d'application animée avec humour et talent lorsqu'on la sélectionne. ;)

Et ce n'est pas tout car
Thomas
fait rarement les choses à moitié ; les fichiers de niveaux perso sont également gérés, après un tel désespoir nous avons les larmes aux yeux de voir qu'ils vont eux aussi pouvoir survivre ! :#tritop#:

Rien de compliqué, il te suffit de copier directement les fichiers de niveaux
.8xv
de ta
TI-83 Premium CE
sur ta
Casio Graph 90+E
ou compatible, et le nouvel
Oiram
se charge de tout, c'est magique ! ;)

12784C'est même plus qu'un portage, il faudrait plutôt parler d'adaptation, ce qui est loin d'être un défaut. ;)

Ce n'est certes pas ce que l'on retenait, mais pour t'offrir un
gameplay
fluide et dynamique malgré les performances très modestes de la
TI-83 Premium CE
,
Oiram CE
se jouait sur un demi-écran,
320×128
pixels au lieu de
320×240
, soit
53,33%
.

Sur ta superbe
Casio Graph 90+E
ou compatible au matériel très supérieur, l'affichage du niveau en cours remplit bien mieux la hauteur de l'écran avec désormais
320×176
pixels pour une toute nouvelle dimension de jeu ; tu pourras mieux anticiper grâce à une meilleure vision des éléments et notamment bonus présents au-dessus et en-dessous de
Mario
! :D

La communauté
Texas Instruments
aujourd'hui en miettes fait ainsi don de
Oiram CE
, sa plus grande création, à la communauté
Casio
. Qu'elle continue à le faire vivre et évoluer, et tant mieux si il lui apporte succès et prospérité, les milliers d'heures de travail passées là-dessus n'auront alors pas été en vain, que le projet ne soit pas oublié c'est tout ce qui compte.

La
Casio Graph 90+E
est désormais la nouvelle calculatrice la plus cool au lycée, la meilleure plateforme nomade scolaire pour les jeux et le développement de jeux ;
Oiram CE
nous te souhaitons bon voyage et bon vent, nous t'avons tant aimé ! :favorite:


Téléchargements
:


Référence
:
https://www.planet-casio.com/Fr/forums/ ... 412--.html

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
:


NESizm 1.0: émulateur NES avec son Graph 90+E fx-CG10/20/50

New postby critor » 13 Aug 2020, 16:13

12255En mars 2020,
Thomas Williamson
sortait pour ta superbe
Casio Graph 90+E
un émulateur de
Nintendo NES
, la console de jeux 8 bits sortie en 1985. :D

L'émulateur est également compatible avec le modèle international
Casio fx-CG50
, ainsi qu'avec les modèles précédents
fx-CG10/20
. :bj:

Un émulateur aux possibilités extrêmement poussées par rapport à ce qui est
(ou était)
offert sur les calculatrices concurrentes, avec nombre de fonctionnalités encore exclusives à ce jour :
  • support aussi bien des jeux pour la console
    Nintendo NES
    internationale de 1985 que pour la console japonaise équivalente
    Nintendo Famicom
    de 1983 ! :D
  • support aussi bien des versions de jeux optimisées pour le standard vidéo
    NTSC
    (Amérique du Nord, Japon, ...)
    que
    PAL
    (Europe, Afrique, ...)
    ! :D
  • en exclusivité à ce jour sur calculatrices, émulation des manettes de
    gaming
    dédiées à la console :
    NES Max
    (boutons turbo)
    et même
    NES Advantage
    (fréquence turbo réglable)
    :bj:
  • autre exclusivité sur calculatrices, sortie audio sur le port
    mini-Jack 2.5
    de la calculatrice à compter de la mise à jour de mai 2020 :#tritop#:
12524


Et bien prépare-toi à du lourd car
Thomas Williamson
nous revient aujourd'hui avec un tout nouveau
NESizm
désormais en version
1.0
! ;)


D'une part, nous t'avions déjà expliqué que la console
NES
disposait d'une fenêtre de seulement
40 Kio
pour adresser le contenu des cartouches de jeu. Or nombre de jeux sont bien plus gros que ça, et embarquent à cette fin un circuit électronique dit
mapper
dans la cartouche, circuit dont le rôle est de présenter à la console à travers cette même fenêtre des zones différentes de la
ROM
lorsque nécessaire. Les
mappers
ont varié d'un éditeur de jeu à un autre, il en existe plein, plusieurs 100aines...
Une difficulté pour les émulateurs
Nintendo NES
est donc qu'ils se doivent également de connaître et émuler le bon fonctionnement de chacun de ces circuits électroniques externes afin de permettre de jouer à un maximum de jeux. Dans sa version précédente,
NESizm
supportait
11
mappers
:
  • NULL
  • MMC1
  • MMC2
  • MMC3
  • MMC6
  • UNROM
  • CNROM
  • AOROM
  • Camerica
  • Colour Dreams
  • Rambo-1
Le support des jeux était ainsi paradoxalement relativement faible par rapport aux émulateurs des calculatrices concurrentes. Beaucoup de jeux populaires ne marchaient pas.

12769Et bien bonne nouvelle, 10 nouveaux
mappers
sont maintenant supportés par
NESizm 1.0
, ce qui permet à
Thomas
de nous annoncer désormais un support de plus de
98%
des jeux commerciaux ! :bj:

Sont ainsi nouvellement supportés :
  • Sunsoft 3
  • Sunsoft 4
  • Sunsoft 5
    , ce dernier servant notamment pour les jeux
    Batman
    dont l'excellent
    Return of the Joker
    ! :bj:
  • NINA-1
  • NINA-02
  • NINA-03
    .
  • BNRON/BxROM
  • GXROM
  • le
    MMC4
    de chez
    Nintendo
    , enfin

Quant au 10ème
mapper
,
Thomas
t'a réservé une énorme surprise. ;)
  • Le 18 décembre 1987 c'est en exclusivité chez
    Nintendo
    que sort ce qui allait devenir un monument du jeu vidéo,
    Final Fantasy
    de chez
    Square
    devenu depuis
    Square Enix
    , initialement pour
    Nintendo Famicom
    japonaise puis le 12 juillet 1990 au format cartouche
    Nintendo NES
    international.
  • Les suites
    Final Fantasy II
    et
    Final Fantasy III
    sortent en 1988 et 1990, mais uniquement pour la
    Nintendo Famicom
    japonaise.
    Il était toutefois possible d'y jouer sur la
    Nintendo NES
    internationale utilisant un format de cartouche différent à l'aide d'un adaptateur de cartouches.
  • En 1991 sort
    Final Fantasy IV
    toujours en exclusivité chez
    Nintendo
    , cette fois-ci pour la nouvelle console
    Nintendo Super Famicom
    .
    Le reste du monde sur la console équivalente
    Nintendo SNES
    également appelée
    Super NES
    ou
    Super Nintendo
    n'est cette fois-ci pas oublié, mais le jeu y est numéroté de façon différente en
    Final Fantasy II
    .
  • Dès 1992 arrive la suite
    Final Fantasy V
    , mais à nouveau uniquement pour la
    Nintendo SuperFamicom
    japonaise.
    Les consoles
    Nintendo SuperNES
    américaines utilisaient un format de cartouche différent, mais avec de gros avantages pour jouer aux jeux japonais. En effet les cartouches japonaises étaient logiciellement compatibles. Elles ne pouvaient être insérées dans le port cartouche un peu plus grand, mais il suffisait juste de couper deux petits ergots de plastique qui bloquaient leur insertion à l'intérieur du port cartouche.
    Les consoles
    Nintendo SuperNES
    européennes bien qu'utilisant le même format cartouche que les japonaises étaient bien plus embêtantes. Bien que les cartouches japonaises pouvaient être insérées elles ne fonctionnaient pas, le système de protection par zonage comme pour les DVD reconnaissant une zone différente. Il fallait ainsi paradoxalement s'encombrer d'un adaptateur.
  • 1994, on reste sur les mêmes consoles,
    Final Fantasy VI
    sort au Japon.
    Le reste du monde y a cette fois-ci de nouveau droit, mais sous la numérotation différente en
    Final Fantasy III
    .
Et puis pour les fans de
Nintendo
l'aventure s'arrête brutalement et cruellement ici, la suite
Final Fantasy VII
de 1997 ne sortira que pour la console concurrente
Sony Playstation
, un véritable déchirement. :'(
Square
faisait en effet le choix du support
CD
, alors qu'en face la nouvelle
Nintendo 64
restait avec le support cartouche qui à l'époque permettait une capacité mémoire bien moindre.

12770Mais c'était sans compter sur le studio de développement chinois
ShenZhen Nanjing Technology
qui a continué à sortir des jeux
Nintendo
bien après la fin de la commercialisation de ces consoles, en réalité destinés à des clones asiatiques. Et en 2005 justement,
ShenZhen Nanjing Technology
réussit l'exploit d'adapter de façon non officielle
Final Fantasy VII
pour
Nintendo NES
! :#tritop#:
La boucle était enfin bouclée, après 8 ans d'attente les fans de
Nintendo
pouvaient enfin découvrir la suite de la série sans avoir à passer à la concurrence ! :D

ShenZhen Nanjing Technology
utilisait pour ses jeux
Nintendo NES
le
mapper
Nanjing 163
, désormais géré par
NESizm
! :o
C'est ainsi que le chaînon manquant
Final Fantasy VII
débarque dès maintenant sur ta
Graph 90+E
! :favorite:


Nous allons te laisser respirer un moment, le temps de te remettre de tes émotions. :p
Traitons donc de quelques nouveautés annexes de
NESizm 1.0
, mais non moins sympathiques pour autant.

La
Nintendo NES
pouvait afficher jusqu'à 52 couleurs différentes dont 5 niveaux de gris, mais avec plusieurs contraintes :
  • 25 couleurs réservées au fond d'écran
  • 12 couleurs réservées aux
    sprites
    avec un maximum de 3 couleurs différentes par
    sprite
  • 25 couleurs différentes au maximum par
    scanline

Ces couleurs étaient définies en dur par la console, tous les jeux puisaient donc parmi les mêmes 52 couleurs.
Toutefois, d'une télévision à une autre le rendu pouvait varier.

Afin de mieux revivre les années 1980 et 1990,
Thomas
t'offre désormais au choix 3 célèbres palettes chez les
gamers
NES
: :bj:
Tu peux même t'amuser à fournir ta propre palette via un fichier au format
.pal
si tu as envie de bouleverser l'expérience de certains jeux ! :D
Des centaines de fichiers
.pal
compatibles sont disponibles en ligne, il te suffira juste d'en copier un sur ta calculatrice sous le nom de
Custom.pal
.

Toujours pour mieux te replonger dans les années 1980 et 1990,
Thomas
t'intègre désormais 3 fonds d'écran également au choix :
  • Warp
    que tu connais déjà
  • TV
    qui reproduit une vieille télévision à gros bouton rotatif du tout début des années 1980
  • black
    pour un fond noir uni
  • ou l'excellent
    Game BG Color
    qui étend la couleur de fond du jeu en cours au reste de l'écran ! :bj:


Rappelons en passant que la
Nintendo NES
gère une définition d'écran de
256×240
pixels
(quasiment un carré donc)
, et que l'écran de ta calculatrice fait
396×224
(environ 16/9)
.
Par défaut tes jeux sont ainsi affichés en
240×224
pixels.

Les fonds
black
et
Game BG Color
sont justement l'occasion d'activer l'option
Stretch
pour élargir l'affichage de tes jeux et te donner une expérience plus proche de celle d'une console portable ! :bj:
  • 4:3
    pour un affichage en
    300×224
    pixels
  • Wide
    pour un affichage en
    360×224
    pixels
    (8/5)

Tu disposes dorénavant d'options pour afficher en bas à droite de l'écran les performances actuelles de ta calculatrice en
fps
(frames per second / images par seconde)
, ainsi que l'horloge système format 12 heures ou 24 heures pourvu que tu l'aies correctement réglée avant. ;)

Autre nouveauté pour une émulation toujours plus exacte tu as maintenant un bouton
RESET
comme sur la vraie console, ici la touche
AC/ON
. :)

NESizm 1.0
te rajoute en plus un lecteur de texte sous la dénomination
FAQ Viewer
.
Cela t'affichera le fichier
.txt
de même nom que le fichier du jeu en cours, fort pratique pour consulter des
FAQ
,
hints
,
cheats
ou
walkthrough
afin de progresser à ton rythme dans tes jeux, sans avoir besoin de t'interrompre en cours de partie pour aller chercher des informations en ligne ! :bj:
Des fichiers ici encore que tu trouveras par centaines en ligne ! :D


C'est bon, tu as eu le temps de reprendre tes esprits ? ;)

On espère, car voici l'autre énorme nouveauté de
NESizm 1.0
, l'émulation d'un tout nouveau périphérique
Nintendo NES
! :bj:
Non, pas le pistolet optique
Nintendo Zapper
, pas non plus le robot
Nintendo ROB
, ça ce sera peut-être pour la prochaine fois. ;)

Mais tu ne devrais pas être déçu(e) pour autant, aujourd'hui nous avons donc droit au
Game Genie
! :D

Il s'agit d'une cartouche qui s'intercalait entre la console et ta cartouche de jeu.

Avant de lancer le jeu branché dessus, la cartouche présentait un écran te permettant de rentrer des codes destinés à
patcher
à la volée des éléments de la
ROM
de ton jeu lors de sa lecture par la console.

C'était l'occasion d'appliquer des correctifs ou mises à jour, même si en pratique la publicité mettait l'accent sur la triche. Possibilité de changer le nombre de vies restantes, le niveau de démarrage, la hauteur de saut...

Il te suffira ici tout simplement de rentrer tes codes
Game Genie
à appliquer dans un fichier texte d'extension
.gg
sous le même nom que le fichier
ROM
de ton jeu.




Casio Graph 90+E
, la meilleure plateforme scolaire pour les jeux et leur développement (*) ! :bj:

(*) surtout depuis la chute de la
TI-83 Premium CE


Téléchargement
:
NESizm

-
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.
525 utilisateurs:
>515 invités
>4 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)