π
<-
Chat plein-écran
[^]

TI-z80 Exploration module Python ti_system TI-83 Premium CE 5.5

New postby critor » Yesterday, 16:30

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à l'application
Python
de ta
TI-83 Premium CE Édition Python
.

Nous sommes honorés aujourd'hui de pouvoir t'en tester une préversion, la
5.5.0031
compilée le
12 Mars 2020
.

Cette mise à jour système s'accompagne d'une mise à jour de l'application
Python
, également en version
5.5.0031
.

Toutefois pas de mise à jour de l'application
PyAdaptr
, sans doute suite à la décision d'interdire le module externe
TI-Python
aux examens français. Aussi, les anciens modèles
TI-83 Premium CE
ne sont-ils hélas pas concernés par les nouveautés
Python
que nous allons aborder. :#non#:


Rien que sur le
Python
il s'agit d'une mise à jour fonctionnelle majeure, et nous ne pourrons pas tout traiter aujourd'hui. Nous n'en allons pas moins te faire déjà découvrir une partie des formidables nouveautés. :)





1) Menus et complexes

Go to top

Une première piste pour découvrir les nouveautés, c'est d'accéder aux menus avec
F1
depuis la console ou l'éditeur de script. Ces menus ne présentent pas la totalité des fonctionnalités, mais une sélection que
Texas Instruments
a choisi de mettre en avant pour une saisie rapide.

Fonctionnellement ce ne sont pas des nouveautés, mais on peut déjà noter quelques ajouts dans les onglets
List
et
E/S
, avec donc l'avantage désormais d'une saisie facilitée :
  • la fonction de classe list.count()
  • la fonction de classe str.format()

Dans l'onglet
Type
par contre, on note :
  • certes la mise au menu de la fonction type()
  • mais surtout une nouvelle fonction complex(real,imag)

Cette fonction complexe(real,imag) à la différence n'était pas simplement non listée sur l'ancienne version mais inexistante. En effet, les nombres complexes n'étaient même pas gérés, contrairement à l'ensemble de la concurrence. Cela voudrait-il dire que c'est le cas désormais ?

Et bien oui les nombres complexes sont maintenant gérés ! :bj:

Ta
TI-83 Premium CE Édition Python
devient donc optimale aussi bien pour le programme de
Mathématiques Terminales S
,
STI2D
et
STL spécialé SPCL
pour le
BAC 2020
, ainsi que le programme de
Mathématiques Expertes
de
Terminale G
et
Maths-Physique-Chimie
de
Terminale STI2D
pour le
BAC 2021
! :D



2) Modules importables et module time

Go to top

Passons maintenant à l'onglet
Modul
pour consulter la sélection de modules importables. Outre
math
et
random
qui était déjà listés, nous avons maintenant :
  • time
  • ti_system
  • ti_plotlib
  • ti_hub
  • ti_rover
  • ainsi qu'un mystérieux
    ti_graphics
    , pour sa part non listé au menu

En réalité, le menu ne liste qu'une sélection et non tous les modules disponibles. Pour cela, on peut appeler help('modules').

Les véritables nouveautés sont donc les seuls modules suivants :
  • ti_plotlib
    , une bibliothèque graphique conformément aux programmes de
    Physique-Chimie
    ,
    SNT
    et
    NSI
    , tout en permettant également nombre d'applications en
    Mathématiques
    ! :bj:
  • ti_system
    , pour enfin pouvoir interagir avec les variables hors application
    Python
    ; enfin l'application
    Python
    pourra véritable servir à résoudre des problèmes et non plus à coder un truc dans un coin ! :bj:
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)

Le module
time
était quant à lui déjà présent, même si on apprécie désormais sa présence au menu et donc la possibilité de lister et accéder rapidement son contenu. :bj:
Cela signifie aussi qu'il est désormais officiel et ne risque plus de disparaître lors d'une prochaine mise à jour - tu peux donc l'utiliser sans crainte ! :D

Nous nous proposons donc aujourd'hui de découvrir avec toi les possibilités d'un premier des nouveaux modules,
ti_system
.




3) Menu ti_system et assistant de saisie

Go to top

On remarque ici plusieurs choses essentielles.

On note une fonction sleep() qui fait apparemment doublon avec celle du module
time
, même comportement.
Au moins cela évitera d'avoir à importer les deux modules dans certains cas. :)

Nous avons donc une fonction escape() qui en pratique indique si les touches
annul
ou
on
sont pressées.
C'est bienvenu, cela permettra d'afficher des informations et d'attendre une confirmation de lecture par l'utlisateur avant de passer à la suite. :)
Si l'on pense conception de menus, interfaces et jeux c'est toutefois insuffisant, et en attendant mieux il y aura la possibilité d'utiliser la bibliothèque tierce
TIKEYLIB
de , qui tente de son mieux de fournir des fonctions utilisables en exploitant le flux d'entrée
sys.stdin
.

Des fonctions
recall…()
permettent d'importer des informations depuis les variables des autres applications de la calculatrice, et store…() inversement d'en exporter.

Des fonctions
disp…()
permettent quant à elles d'afficher des caractères à l'écran.

Notons à ce sujet le fonction disp_at(ligne,'txt','align'), qui est suffixée au menu d'un petit triangle vert orienté vers la droite.
Non il ne t'invite pas à taper
comme on pourrait le croire, mais t'indique que la validation de ce choix va ouvrir un assistant illustré ci-contre.
En effet, cette fonction attend ici comme dernier paramètre une chaîne avec comme seules valeurs autorisées
'left'
,
'center'
ou
'right'
, pénibles à saisir.
L'assistant est donc là pour te lister les valeurs autorisées pour ce genre de paramètres, et t'en faciliter la saisie. :)

Nous explorer plus en détails ces deux dernières catégories de fonctions ci-après.




4) Exploration ti_system et touches clavier

Go to top

Et si le module
ti_system
contenait des choses non listées au menu ?

Réalisons-en une exploration complète à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ('HP' in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=''
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input('Input to continue:')
    curline=0
  print(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):
  s=str(obj)
  return s.startswith('<') and s.find(' ')>=0

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd='.'*(len(pitmsl)-1)
  spath='.'.join(pitmsl)
  c,c2=0,0
  spitm=str(pitm)
  for itms in sorted(dir(pitm)):
    c,c2=c+1,c2+1
    try:
      itm=eval(spath+'.'+itms)
      mprint(hd+itms+'='+str(itm))
      if isExplorable(itm) and itm!=pitm:
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c2=c2+explmod(itm,pitmsl2,False)[1]
    except:
      mprint(hd+itms)
  if c>0 and reset:
    mprint(hd+'Total: '+str(c)+' 1st level item(s)')
    if c2>0 and c2!=c:
      mprint(hd+'       '+str(c2)+' item(s)')
  return [c,c2]

Un import ti_system suivi d'un appel explmod(ti_system) nous révèle effectivement plusieurs fonctions cachées :
  • wait()
  • et
    wait_key()

La fonction
wait()
semble se comporter exactement comme
sleep()
.

Et bien finalement non, pas besoin d'aller chercher une bibliothèque tierce de détection des touches pressées pour tes menus, interfaces et jeux, la fonction
wait_key()
semble être exactement ce qu'il nous fait.
Comme le
getKey
du
TI-Basic
, elle renvoie toujours un même code numérique pour chaque touche pressée.

Quelques différences toutefois :
  • ce ne sont, bizarrement, pas les mêmes codes qu'en
    TI-Basic
  • ici la fonction attend la pression d'une touche avant de renvoyer une valeur
  • les touches modificatrices
    2nde
    et
    alpha
    ne sont pas gérées

Ah ben en fait voilà qui explique l'utilisation de codes touches différents; lorsque précédant l'appui sur une touche,
2nde
et
alpha
modifient le code retourné.

Toutefois, tant que ce n'est pas au menu, ce n'est pas officiel et ça peut être retiré à tout moment.

Voici ici documenté les codes de chacune des touches, suivis à chaque fois des codes obtenus en combinaison avec les modificateurs
2nde
puis
alpha
si différents :
f(x)

73
48
fenêtre

72
75
zoom

46
87
trace

90
59
graphe

68
74
2nde
mode

69
64
suppr

10
11

2
14

3
alpha
X,T,θ,n

180
65
stats

49
58

4

1
15
math

50

51

154
matrice

55
182

155
prgm

45
47

156
var

53
56
annul

9
◄►

64018
57

157
trig

64017
181

158
résol

64020
44

159
□/□

64458
64016

160
^

132

161

189
190

162
,

139
152

163
(

133
236

164
)

134
237

165
/

131
239

166
log

193
194

167
7

149
249

168
8

150
250

169
9

151
251

170
×

130
135

171
ln

191
192

172
4

146
246

173
5

147
247

174
6

148
248

175
-

129
136

176
sto→

138
12

177
1

143
243

178
2

144
244

179
3

145
245

204
+

128
54

203
on

0
0

142
153

62
.

141
238

198
(-)

140
197

202
entrée

5
13


Ah ben en fait, nous avons beau y regarder ces codes nous sont totalement obscurs. Nous n'y voyons aucune logique globale.

C'est donc en effet un travail inachevé; si ces codes sont conservés en l'état il faudra concevoir un menu dédié pour faciliter leur utilisation.




5) ti_system et fonctions disp…

Go to top

Contrairement à la fonction
Python
print() qui ne permet d'afficher qu'à la fin de la console et te pousse donc à la gymnastique pour des affichages multilignes, les fonctions d'affichage fournis par le module
ti_system
tiennent compte de la géométrie écran de la calculatrice pour t'offrir le choix d'afficher une chaîne où tu veux et quand tu veux, dans le même esprit que le langage de programmation historique
TI-Basic
.

disp_cursor(0) et disp_cursor(1) permettant respectivement de désactiver et réactiver l'affichage du curseur de texte pendant l'exécution de tes scripts
Python
.

disp_clr() quant à elle efface l'écran de la console et ramène le curseur tout en haut à gauche pour le prochain affichage.

disp_wait() attend l'appui sur une touche d'annulation puis efface l'écran, semblant être équivalent au code suivant :
Code: Select all
while not escape():
  pass
disp_clr()


Enfin nous arrivons à la fonction principale, disp_at(ligne,'txt','align'), et allons tenter d'en comprendre le fonctionnement. On peut l'illustrer ci-contre à l'aide du code suivant :
Code: Select all
from ti_system import *

for k in range(1, 12):
  disp_at(k,('Ligne {:02d} ' + '*'*23).format(k),'left')
disp_at(6,'left','left')
disp_at(8,'center','center')
disp_at(10,'right','right')
disp_at(3,'123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ','left')


Tu peux donc afficher tes caractères à largeur fixe où tu veux sur 11 lignes numérotées de 1 à 11, et 32 colonnes.
Pour tout affichage la fonction
disp_at()
n'efface pas le début de ligne, écrase les caractères déjà affichés au même endroit si il y en a, et va automatiquement à la ligne au-delà de la 32ème colonne.
En ce sens, elle est comparable à la fonction
Output()
du langage
TI-Basic
historique, et te permettra donc de réaliser des interfaces et menus textuels mais cette fois-ci en
Python
. :bj:


Toutefois, précisons que la fonction
disp_at()
diffère également de
Output()
de plusieurs façons.
  • pour tout affichage effectué, si elle n'efface pas le début de ligne elle efface quand même systématiquement la fin de la ligne
  • si elle te permet de choisir la ligne de ton affichage elle ne te permet que très peu d'en contrôler la colonne, ne te donnant que le choix d'afficher ton texte aligné à gauche, droite ou centré
Porter tes programmes
TI-Basic
fonctionnant en mode texte nécessitera donc d'en adapter la logique d'affichage.


Voyons voir si nous pouvons remédier à ces derniers points, et te proposer quelque chose d'un peu plus proche de la fonction
Output()
du
TI-Basic
.

Voici par exemple une fonction
outputl()
qui te permet de choisir en prime le numéro de colonne de 1 à 32, et utilise l'alignement à gauche :
Code: Select all
from ti_system import *

def outputl(l, c, s):
  s = ' ' * (c-1) + s
  disp_at(l, s, 'left')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputl(3, 6, 'test1')

while not espace():
  pass

La fonction
outputl()
préfixe ici ta chaîne d'autant d'espaces que nécessaires pour l'afficher à la colonne de ton choix.
Toutefois elle a le défaut d'afficher non seulement la fin de ligne mais également le début de ligne, te contraignant donc à construire ton affichage en réalisant un unique affichage par ligne.

Changeons de méthode, voici une fonction
outputr()
qui utilise pour sa part l'alignement à droite :
Code: Select all
from ti_system import *

def outputr(l, c, s):
  s += ' ' * (32-len(s)-c+1)
  disp_at(l, s, 'right')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test2')

while not espace():
  pass

Ici la fonction affiche la chaîne en alignement à droite en la suffixant d'autant d'espaces que nécessaire pour atteindre la position demandée, avec l'avantage de ne pas effacer le début de ligne.
Même si elle efface quand même la fin de ligne, tu pourras à la différence avec cette fonction réaliser plusieurs affichages par ligne pour tes scripts, à la condition de les effectuer dans l'ordre du plus à gauche au plus à droite.

Et si on tentait avec un alignement au centre ? Ici l'avantage serait d'avoir à rajouter beaucoup moins d'espaces.
A priori cela n'empêchera certes pas l'effacement de la fin de ligne, mais et si on tenter de suffixer le tout d'un caractère retour à la ligne ?
Code: Select all
from ti_system import *

def outputc(l, c, s):
  s += ' ' * (32-2*c-len(s))
  s += '\n'
  disp_at(l, s, 'center')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test3')

while not espace():
  pass

Ici donc pas d'effacement du début de ligne, et la fin de ligne n'est que partiellement effacée.
Toutefois la fonction a l'inconvénient d'effacer la ligne suivante, et c'est donc ici dans l'ordre de haut en bas que tu devras effectuer tes affichages.

Pour afficher tes interfaces multilignes, le meilleur choix semble donc être entre ces deux dernières fonctions,
outputr()
et
outputc()
, avec chacune des avantages et des inconvénients. Tu es libre de les reprendre pour tes futurs scripts
TI-83 Premium CE Édition Python
. :)




6) ti_system et importation/exportation de données

Go to top

Grâce au module
ti_system
, on peut désormais importer dans l'application
Python
des données provenant des autres applications de la calculatrice.

recall_RegEQ() par exemple récupère sous forme de chaine le membre de droite l'expression réduite
$mathjax$y=f(x)$mathjax$
trouvée lors de la dernière régression statistique effectuée sur la calculatrice.

recall_list("nom") quant à elle permet de récuperer en
Python
l'une des listes créées dans le contexte des autres applications de la calculatrice.

Exemple de suite sur ce dernier point, utilisation l'application
ProbSim
pour lancer simulatanément 3 dés, et ce 100 fois de suite.

L'application permet alors d'exporter les données générées dans des listes aux noms prédéfinis.


Comme le menu de l'application
Python
nous y invitait, on peut alors mettre le contenu d'une de ces listes, par example
⌊SOMME
, dans l'une des listes prédéfinies
L1
à
L6
, par exemple
L1
.


On peut alors récupérer les données brutes de la somme des dés en
Python
en utilisant recall_list('1') et commencer à les exploiter, par exemple en les convertissant en données de modalités et effectifs ou encore en en demandant les paramètres statistiques à l'aide des fonctions suivantes.

Note bien que hors du contexte
Python
, ta calculatrice ne travaille que sur des nombres flottants. Comme tu peux l'observer ci-contre tu récupères donc ici forcément une liste de flottants, il faudra éventuellement en tenir compte selon ce que tu comptes faire avec.

Code: Select all
from math import *

def brut2valeff(l):
  """ Prend en paramètre une liste de valeurs.
      Renvoie une liste de 2 liste :
      - les valeurs uniques
      - les effectifs associés
  """
  d=dict()
  for v in l:
    if not(v in d.keys()):
      d[v]=0
    d[v]+=1
  return [list(d.keys()),list(d.values())]

def stats1var(lv, lf=[]):
  """ Prend en paramètre :
      - une liste de valeurs
      - liste optionnelle des effectifs / fréquences associées
      Renvoie la liste des paramètres statisques correspondants :
      effectif total, moyenne, variance, écart-type, mode,
      minimum, maximum, quartile 1, médiane, quartile3
  """
  if(len(lf) == 0):
    lf = [1 for k in range(len(lv))]

  params = []
  lz = sorted(zip(lv, lf))

  params.append(sum(lf))
  print('Effect tot:', params[0])

  s, s2 = 0, 0
  for k in lz:
    s += k[0]*k[1]
    s2 += k[0]**2*k[1]
  params.append(s/params[0])
  params.append(s2/params[0]-params[1]**2)
  print('Moyenne   :', params[1])
  print('Variance  :', params[2])

  params.append(sqrt(params[2]))
  print('Ecart-type:', params[3])

  zmode, zmin, zmax = lz[0], lz[0], lz[0]
  for k in lz:
    if k[1]>zmode[1]:
      zmode = k
    if k[0]<zmin[0]:
      zmin = k
    if k[0]>zmax[0]:
      zmax = k
  params.extend([zmode[0], zmin[0], zmax[0]])
  print('Mode      :', params[4])
  print('Minimum   :', params[5])

  s, k = 0, -1
  while(s<params[0]/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile1:', params[7])

  while(s<params[0]/2):
    k += 1
    s += lz[k][1]
  if(2*s == params[0]):
    params.append((lz[k][0]+lz[k+1][0])/2)
  else:
    params.append(lz[k][0])
  print('Médiane  :', params[8])

  while(s<params[0]*3/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile3:', params[9])

  print('Maximum  :', params[6])

  return params


Petite limitation à ce jour, la liste importée ne doit pas comporter plus de 100 éléments, sans quoi l'importation sera refusée. C'est dommage, les programmes scolaire invitant à faire travailler les statistiques avec des données réelles notamment dans le contexte de l'outil numérique, données qui excéderont bien souvent les 100 éléments.

Remarque, contrairement à ce que nous suggérait le menu
Python
nous n'avions ici aucun besoin de passer par la liste prédéfinie
L1
.

Inversement maintenant, grâce à la fonction store_list("nom",var) on peut exporter les listes remplies dans le contexte
Python
vers des variables listes qui seront utilisables par les autres applications de la calculatrice.

Les nombres entiers sont alors convertis en nombres flottants comme l'on peut le constater en réimportant immédiatement les exportations.

A noter que la calculatrice hors du contexte
Python
gère deux types de listes :
  • les listes de nombres réels
  • les listes de nombres complexes

Si l'un des éléments de la liste exportée est de type complexe, ce sont tous les nombres de la liste qui seront convertis en type complexe comme l'on peut le constater à la réimportation.

Et puis c'est tout, la calculatrice ne gère hors
Python
que des listes de nombres. Tout élément non numérique interrompra l'exportation.

Mine de rien, il s'agit de fonctionnalités formidables, en parfaite adéquation avec les programmes scolaires. Ces derniers demandent en effet :
  • pour les statistiques, de travailler sur des données réelles, qui une fois transférées à la calculatrice seront donc maintenant récupérables dans l'application
    Python
  • d'enseigner le
    Python
    non pas dans le bête but de coder, compétence technique peu intéressante en soi, mais comme outil transversal de résolution de problèmes
Jusqu'à présent la
TI-83 Premium CE Édition Python
avait le défaut d'avoir son application
Python
qui tournait en vase clos, sans aucun échange possible avec le reste des applications du logiciel de Mathématiques intégré de la calculatrice. Elle ne permettait donc bêtement que de coder dans son coin et pas de résoudre des problèmes, c'est-à-dire de faire appel à plusieurs applications de la calculatrice pour traiter différemment les mêmes données. Et d'ailleurs, même reproche à ce jour pour l'ensemble de la concurrence. :mj:

Texas Instruments
est donc le premier constructeur à s'attaquer à ce défaut et à nous proposer quelque chose d'innovant, le
Python
de ta
TI-83 Premium CE Édition Python
va enfin pouvoir te servir à faire des Maths/Sciences et non plus seulement du code, félicitations ! :bj:

De plus, rappelons que
TI-Connect CE
te permet d'importer des fichiers de données
.csv
que tu peux notamment exporter à partir de feuilles de calculs, de quoi travailler encore plus facilement et rapidement sur des données réelles ! :bj:

Tutos TI-83 Premium CE Édition Python 5.5
:


TI-z80 Récupération nouvelle version OS 5.4.1.0052 TI-84 Plus CE

New postby critor » 28 Mar 2020, 20:18

Dans le contexte sanitaire actuel,
Texas Instruments
met à disposition gratuitement sa toute nouvelle application d'émulation
TI-SmartView CE
pour les
Chromebook
, ordinateurs équipés du système d'exploitation
Chrome OS
. Plus précisément il s'agit d'un émulateur du modèle international
TI-84 Plus CE
, et pas du modèle français équivalent
TI-83 Premium CE
.

Nous découvrions justement à cette occasion que l'émulateur était équipé d'un système (OS) en version
5.4.1.0052
, soit plus récent donc que la dernière version diffusée à ce jour sur le site de
Texas Instruments
, la
5.4.0.0034
compilée le
31 Mai 2019
.

Peut-être cette nouvelle version
5.4.1
n'est elle incluse que dans les calculatrices sortant actuellement d'usine, ou peut-être s'agit-il simplement d'une version mineure intermédiaire.

12381Quoi qu'il en soit, les émulateurs
TI-SmartView CE
ayant l'avantage d'être suffisamment fidèles au matériel, nous avons pu
dumper
le contenu de la mémoire
Flash
virtuelle contenant la version
5.4.1
, et en générer un fichier de mise à jour pour la calculatrice. :)

Et bingo, la version
5.4.1
marche parfaitement une fois installée sur une véritable
TI-84 Plus CE
comme tu peux le constater ci-contre ! :bj:

Nous ignorons toutefois à ce jour les changements associés à cette version
5.4.1
, n'hésite pas à la tester et à les partager si tu en découvres. ;)

Il est à noter que la version
5.4.1
ne renforce pas la protection contre la réinstallation de versions inférieures. Comme ses prédécesseurs, la version minimale autorisée qui lui est associée reste
5.3.6
.
Si tu as donc déjà mis à jour ta
TI-84 Plus CE
en version
5.3.6
ou supérieure, tu peux donc installer sans crainte la version
5.4.1
et par la suite si tu le souhaites revenir librement aux versions
5.4.0
ou
5.3.6
. :)

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

NumWorks NumWorks 13.1 : unités + études nombres + touches Python

New postby critor » 28 Mar 2020, 09:35

12312Dans la crise sanitaire actuelle,
NumWorks
reste à tes côtés. Afin de t'accompagner dans tes apprentissages et devoirs avec un outil toujours plus exceptionnel, la nouvelle version
NumWorks 13
est maintenant disponible. :)

Plus précisément il s'agit de la version
13.1.0
et nous allons découvrir ensemble les nouveautés apportées :




1) Clavier et interface

Go to top

Déjà grande nouveauté, dans l'ensemble des applications il t'est enfin possible de sélectionner naturellement du texte dans une zone de saisie. Cela se passe aussi naturellement que sur ordinateur, en maintenant la touche
shift
puis une touche fléchée. :)

La sélection pourra alors être coupée-copiée-collée-effacée à l'aide des raccourcis clavier. :)

C'est particulièrement bienvenu dans le cadre de l'application
Python
, pour une saisie encore plus rapide et donc agréable de tes scripts lorsqu'ils comporteront plusieurs lignes ou blocs similaires ! :bj:

Notons également que le défilement des tableaux de valeurs présentés par les divers applications a été accéléré.




2) Paramètres et mode examen

Go to top

Afin de cibler les besoin des différents pays et examens, la calculatrice dispose désormais de 2 modes examen au choix :
  1. Standard
    , qui efface le contenu mémoire sans limitation de fonctionnalités comme exigé en France.
  2. Dutch
    , ciblant la réglementation plus restrictive des Pays-Bas qui viennent tout juste d'autoriser la calculatrice
    NumWorks
    aux examens.
Si tu ne vois rien c'est normal, le choix de ce 2ème mode examen n'est pas proposé lorsque la calculatrice est réglée en langue française. La calculatrice ne parlant pas non plus néerlandais pour le moment, à ce jour tu devras la basculer en anglais pour le faire apparaître.

En plus du contenu mémoire, ce mode examen
Dutch
désactive comme indiqué l'application
Python
, car les Pays-Bas interdisent l'accès à tout éditeur de texte pendant les épreuves.

Et bien évidemment, une fois le mode examen néerlandais activé, il n'est plus possible d'altérer ces restrictions sans désactiver le mode examen et donc éteindre la diode. A priori
NumWorks
a bien codé la chose; changer la langue ou réactiver le mode examen ne permet pas de récupérer l'accès à l'application
Python
.

Les deux modes examens produiront de plus un signal différent sur la diode :
  • rouge en mode examen
    Standard
  • jaune en mode examen
    Dutch
Voilà qui permettra aux surveillant de détecter les candidats qui n'auraient pas activé le bon mode, surtout aux Pays-Bas.

Enfin en ce qui nous concerne, notons qu'une fois le mode examen activé, son écran affiche maintenant les instructions permettant de le désactiver, à savoir la connexion à toute source d'alimentation USB
(ordinateur, tablette, smartphone OTG, batterie USB, chargeur USB, ...)
. :bj:




3) Paramètres et Python

Go to top

L'application
Paramètres
offre de plus désormais un nouveaux choix, celui de la taille de police qui sera utilisée dans l'application
Python
:
  • Grande
    qui correspond à la taille utilisée jusqu'ici et permet d'afficher
    12
    lignes sur
    29
    colonnes
  • Petite
    qui permet quant à elle d'afficher
    16
    lignes sur
    42
    colonnes
Notons de plus que ce réglage s'applique aussi bien à l'éditeur qu'à la console
Python
. De quoi te permettre une bien meilleur vue d'ensemble de tes scripts ainsi que de leur affichage - merci
NumWorks
! :bj:
1232912328




4) Python

Go to top

En ce qui concerne maintenant le langage
Python
nous avons beaucoup d'améliorations et nouveautés, n'ayons pas peur des mots et disons même énormément. :D

Déjà, autre amélioration de saisie mais dans le contexte
Python
, le catalogue accessible via la boîte à outils inclut désormais les fonctions associées à la classe
list
: :)
  • list.append(x)
  • list.clear()
  • list.count(x)
  • list.index(x)
  • list.insert(i,x)
  • list.pop(i)
  • list.remove(x)
  • list.reverse()
  • list.sort()

En
Python
les possibilités d'interactions avec des interfaces, notamment pour des menus ou jeux, étaient très limitées sur la
NumWorks
.

En effet, il n'y avait pas de fonction permettant de tester la pression d'une touche. Pas d'autre choix donc jusqu'à présent que de passer par la fonction
input()
, avec donc obligation pour l'utilisateur de valider avec
EXE
à chaque action, ce qui déjà rendait impossibles nombre de types de jeux.

NumWorks
s'attaque enfin au problème dans cette dernière version, avec un nouveau module
ion
à cette fin dont voici l'exploration avec notre script :
Code: Select all
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(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):
  s=str(obj)
  return s.startswith("<") and s.find(" ")>=0

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c,c2=0,0
  spitm=str(pitm)
  for itms in sorted(dir(pitm)):
    c,c2=c+1,c2+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm) and itm!=pitm:
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c2=c2+explmod(itm,pitmsl2,False)[1]
    except:
      mprint(hd+itms)
  if c>0 and reset:
    mprint(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      mprint(hd+"       "+str(c2)+" item(s)")
  return [c,c2]

12373123741237512376

C'est l'occasion pour nous de te fournir une table des codes clavier retenus, où la logique visuelle de numérotation t'aidera peut-être à retenir : :)

0

1

3

6
OK

4

5

2
shift

12
alpha

13
x,n,t

14
var

15
╒╕

16

17
e^x

18
ln

19
log

20
i

21
,

22
x^y

23
sin

24
cos

25
tan

26
π

27

28

29
7

30
8

31
9

32
(

33
)

34
4

36
5

37
6

38
×

39
÷

40
1

42
2

43
3

44
+

45
-

46
0

48
.

49
×10^x

50
Ans

51
EXE

52


12338On peut toutefois remarquer que la seule fonction fournie
keydown()
par le nouveau module
ion
ne permet que de savoir si une touche donnée est pressée ou pas.
Des scripts
Python
implémentant des jeux ou interfaces
(pourquoi pas une boîte de saisie texte)
vont donc devoir appeler cette fonction autant de fois qu'il y a de touches clavier traitées. On peut donc légitimement s'interroger sur ce que donne le temps d'exécution de la fonction potentiellement multiplié par les 46 touches clavier
(ou plutôt 45, la touche d'allumage/exinction n'étant pas gérée par le module)
.

Et bien testons, voici , notre script où il te suffira d'un simple et unique appel
getkeys()
pour scanner l'ensemble de la matrice clavier et récupérer la liste des codes des touches actuellement pressées :
Code: Select all
from ion import keydown

def keycodes():
  lc = list(range(0,6)) + list(range(12,35))
  for k in range(36,53):
    if (k+1)%6:
      lc.append(k)
  return lc

def getkeys():
  lk = []
  for k in keycodes():
    if keydown(k):
      lk.append(k)
  return lk


12339Nous allons de plus chronométrer l'appel
getkeys()
à l'aide de notre script :
Code: Select all
from time import monotonic

def timer(f, *par):
  start=monotonic()
  f(*par)
  return monotonic()-start

L'appel maintenant devenu
timer(getkeys)
nous mesure donc autour 0,08 seconde pour le scan intégral du clavier, aussi bien sur
N0100
que
N0110
.

8 centièmes de seconde ce n'est certes pas rien, mais c'est quand même très loin d'être la catastrophe que nous craignions.
NumWorks
semble avoir bien fait les choses. :)
Les jeux
Python
utilisant beaucoup de touches clavier seraient donc en théorie limités au mieux à 25 fps
(images par seconde)
, ce qui est tout de même déjà humainement très acceptable. En pratique il suffira aux jeux en question de ne pas scanner l'intégralité du clavier mais seulement les touches utiles, et de toutes façons la lenteur des fonctions graphiques à ce jour ne pemet pas d'atteindre les
25 fps
en
Python
même sans aucune lecture clavier.

En passant, si toi aussi tu souhaites optimiser tes tests de touches clavier dans le même style que notre fonction
getkeys()
, n'hésite pas à consulter le tutoriel associé à la nouvelle fonction
keydown()
.

12378De toutes nouvelles interfaces et jeux deviennent envisageables possibles sur ta
NumWorks
, et s'est dépêché de te les illustrer ci-contre avec le premier jeu utilisant le module
ion
, un ! :bj:


Suite à cet ajout majeur, profitons-en pour voir où nous en sommes niveau
Python
sur calculatrices. Voici déjà l'éventail des modules disponibles :

autorisés aux
examens français
inutilisables aux
examens français
NumWorks
Casio Graph
35+E II
90+E
TI-83PCE
Ed. Python
MicroPython
TI-Nspire
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
TI-Python
builtins
array
collections
cmath
gc
math
micropython
os
random
sys
time
turtle
uerrno

.
.

.


.

.


.

.
.
.
.

.
.

.
.
.
.



.


.
.



.
.


.




.
.

.
.


.




.
.

.
.
.


.




.


.
.



.


.
.



.
.











.
.
spécifique
kandinsky
ion
prime
nsp
board
storage
Total
9
3
8
9
8
9
9
13

En terme de quantité de modules, la
NumWorks
arrive ainsi désormais au premier rang des solutions
Python
utilisables aux examens français, félicitations ! :bj:
Aux examens :
  1. 9
    modules :
    NumWorks

    HP Prime
    (version alpha)
  2. 8
    modules :
    TI-83 Premium CE Edition Python
  3. 3
    modules :
    Casio Graph 35+E II
    Casio Graph 90+E
Hors examens :
  1. 13
    modules :
    TI-Python
    (firmware tiers)
  2. 9
    modules :
    NumWorks

    Casio Graph 35+E II
    Casio Graph 35+E/USB
    Casio Graph 75/85/95
    Casio fx-9750GII
    Casio fx-9860GII
    Casio fx-9860G

    (appli CasioPython)

    HP Prime
    (version alpha)
  3. 8
    modules :
    TI-83 Premium CE Edition Python

    TI-Python

    TI-Nspire
    (appli MicroPython)
  4. 3
    modules :
    Casio Graph 35+E II
    Casio Graph 90+E
    Casio fx-CG50


Et voici maintenant pour le contenu de ces mêmes modules :

autorisés aux
examens français
inutilisables aux
examens français
NumWorks
Casio Graph
35+E II
90+E
TI-83PCE
Ed. Python
MicroPython
TI-Nspire
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
TI-Python
builtins
array
collections
cmath
gc
math
micropython
os
random
sys
time
turtle
uerrno
88-188
.
.
12
.
41
6
.
9
.
3
38
.
84-175
.
.
.
.
25
.
.
8
.
.
.
.
92-189
2-4
2
.
7
28
.
.
8
15-42
4
.
.
97-440
3-13
.
13-17
9-13
42-46
10-14
.
.
17-63
.
.
25-29
93-218
2-4
.
12
7
41
3
.
.
15-45
.
.
.
91-204
2-4
.
12
7
41
6
.
8
12
.
.
24
92-189
2-4
2
.
7
28
.
.
8
15-42
4
.
.
93-191
2-4
2
12
7
41
6
15
8
15-45
8-10
.
.
spécifique
6
(kandinsky)

48
(ion)
3-7
(prime)
3-10
(nsp)
22
(board)

7-21
(storage)
Total
251-351
117-208
158-284
219-642
176-340
203-318
158-284
238-384

En terme de richesse des modules, la
NumWorks
varie donc entre les 2ème et 3ème rangs ! :bj:
Aux examens :
  1. 219-642
    éléments :
    HP Prime
    (version alpha)
  2. 251-351
    éléments :
    NumWorks
  3. 158-284
    éléments :
    TI-83 Premium CE Edition Python
  4. 117-208
    éléments :
    Casio Graph 35+E II
    Casio Graph 90+E
Hors examens :
  1. 219-642
    éléments :
    HP Prime
    (version alpha)
  2. 238-384
    éléments :
    TI-Python
    (firmware tiers)
  3. 251-351
    éléments :
    NumWorks
  4. 176-340
    éléments :
    TI-Nspire

    (appli MicroPython)
  5. 203-318
    éléments :
    Casio Graph 35+E II
    Casio Graph 35+E/USB
    Casio Graph 75/85/95
    Casio fx-9750GII
    Casio fx-9860GII
    Casio fx-9860G

    (appli CasioPython)
  6. 158-284
    éléments :
    TI-83 Premium CE Edition Python

    TI-Python
  7. 117-208
    éléments :
    Casio Graph 35+E II
    Casio Graph 90+E


Parlons maintenant mémoire. En
Python
il y a plus précisément 3 mémoires :
  • la mémoire de stockage qui accueille et conserve tes scripts
  • le
    stack (pile)
    qui, à l'exécution, accueille les références vers les objets créés
  • le
    heap (tas)
    qui, à l'exécution, accueille les valeurs de ces objets

Avec la dernière version, tu disposais d'une mémoire de stockage pouvant accueillir jusqu'à
16 Kio
de scripts
Python
.
La nouvelle version te double dès maintenant l'espace de stockage, avec pas moins de
32 Kio
! :bj:

Pour le reste, le
stack / pile
limite donc la quantité d'objets différents utilisables simultanément, alors que le
heap / tas
en limite le volume.
La
NumWorks
était très décevante dans les deux cas, se retrouvant sur ces points littéralement à la queue de l'ensemble des solutions
Python
sur calculatrices graphiques. :mj:


Notre script permet d'estimer la capacité du
heap / tas
:
Code: Select all
def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

Celle-ci faisait
16 Kio
sur les
firmwares
officiel, et cela n'a malheureusement pas changé pour la version
13.1.0
.

En conséquence, vu les tailles non négligeables prises en mémoire par les objets
Python
les plus simples, tu seras très rapidement limité(e) dès que tes scripts vont commencer à travailler sur des tuples, listes ou pire listes de listes. :mj:


D'où le classement :
Aux examens :
  1. 1,032942 Mo
    :
    Casio Graph 90+E
  2. 1,022145 Mo
    :
    HP Prime
    (version alpha)
  3. 100,560 Ko
    :
    Casio Graph 35+E II
  4. 32,339 Ko

    NumWorks
    (firmware )
  5. 20,200 Ko

    TI-83 Premium CE Edition Python
  6. 16,259 Ko

    NumWorks
Hors examens :
  1. 2,049276 Mo
    :
    TI-Nspire
    (application MicroPython)
  2. 1,032942 Mo
    :
    Casio Graph 90+E
  3. 1,022145 Mo
    :
    HP Prime
    (version alpha)
  4. 257,636 Ko
    :
    Casio Graph 35/75+E
    (application CasioPython)
  5. 100,560 Ko
    :
    Casio Graph 35+E II
  6. 32,339 Ko

    NumWorks
    (firmware )
  7. 31,899 Ko
    :
    Casio Graph 35+E II
    (application CasioPython)
  8. 22,605 Ko

    TI-83 Premium CE + TI-Python
  9. 20,200 Ko

    TI-83 Premium CE Edition Python
  10. 19,924 Ko

    TI-83 Premium CE + TI-Python
  11. 16,238 Ko

    NumWorks


Par contre,
NumWorks
annonce avoir quadruplé la taille de la
pile / stack
pour la version
13.1
, voyons cela. Comme déjà expliqué, cette augmentation devrait permettre d'avoir simultanément davantage d'objets en mémoire
(mais pas davantage de données, les valeurs de ces objets allant comme déjà dit dans le tas / heap)
. C'est la même capacité que l'on peut partager entre davantage d'objets différents.

Comment mesurer cela ? Une situation qui permet de créer plein de références dans la
pile / stack
, c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons notre script
recur.py
:
Code: Select all
def sumr(n):return n>0 and n+sumr(n-1)

def maxr(fct):
  n=0
  try:
    while True:
      fct(n)
      n=n+1
  except Exception as e:print(e)
  return n

12341L'appel
maxr(sumr)
permet en effet de constater un bon quadruplement du nombre maximal d'appels récursifs, passant de
30
à
143
avant le déclenchement de l'erreur
maximum recursion depth exceeded
, de quoi étudier et exploiter désormais bien plus sérieusement la récursivité ! :bj:

Là encore une nette progression au classement en terme de capacité de
pile / stack
. Merci
NumWorks
, la calculatrice est donc dès maintenant le meilleur choix aux examens français sur le critère de la récursivité ! :bj:
Aux examens :
  1. 143
    :
    NumWorks
    (nouvelle version)
  2. 82
    :
    Casio Graph 90+E

    Casio Graph 35+E II
  3. 77
    :
    HP Prime
    (version alpha)
  4. 30
    :
    NumWorks
    (ancienne version)
  5. 23

    TI-83 Premium CE Edition Python
Hors examens :
  1. 5362
    :
    Casio Graph 35/75+E
    (application CasioPython)
  2. 655
    :
    Casio Graph 35+E II
    (application CasioPython)
  3. 143
    :
    NumWorks
    (nouvelle version)
  4. 130
    :
    TI-Nspire
    (application MicroPython)
  5. 82
    :
    Casio Graph 90+E

    Casio Graph 35+E II
  6. 77
    :
    HP Prime
    (version alpha)
  7. 30
    :
    NumWorks
    (ancienne version)
  8. 23

    TI-83 Premium CE Edition Python
  9. 20

    TI-83 Premium CE + TI-Python
  10. 15

    TI-83 Premium CE + TI-Python




5) Calculs

Go to top

NumWorks
n'a également pas chômé avec l'application
Calculs
et nous apporte ici encore pléthore de nouveautés.

Déjà petite mise en bouche,
NumWorks
améliore l'intelligence de sa saisie. Lorsque par exemple on note
f(5)
, sans connaître le contexte il y a ambiguité. Selon le contexte, cela peut être :
  • si
    f
    est une fonction, la fonction
    f
    appliquée à 5
  • sinon, le produit de
    f
    par 5
Jusqu'à la dernière version, la
NumWorks
considérait systématiquement que c'était un appel de fonction, même si
f
n'en était pas une, et ne te donnait donc aucun résultat. :(

Désormais ta
NumWorks
tiens compte du contexte, et t'interprétera automatiquement cette saisie en tant que produit si
f
n'a pas été définie en tant que fonction. :)


La
NumWorks
te permet désormais de calculer avec des nombres écrits en base non décimale : :bj:
  • base binaire en préfixant le nombre saisi par
    0b
  • base hexadécimale en préfixant le nombre saisi par
    0x

Le résultat reste certes affiché en base décimale, et il n'y a pas d'option pour changer cela.
Toutefois,
NumWorks
a prévu autre chose pour tes conversions dans l'autre sens. Si tu remontes dans l'historique de calculs avec la touche
, chaque résultat entier sélectionné se verra adjoindre un bouton qu'il te suffira de valider pour obtenir automatiquement des résultats additionnels :
  • la conversion en base hexadécimale :bj:
  • la conversion en base binaire :bj:
  • la décomposition en facteurs premiers :)
Et nul besoin de les noter sur ton brouillon, les différents résultats peuvent de plus être sélectionnés puis directement copiés-collés à des fins de réutilisation immédiate ! :bj:

Mais ce n'est pas tout,
NumWorks
te propose également des résultats additionnels de façon similaire en cas de résultat rationnel
(écriture exacte en fraction)
, avec :
  • la conversion en fraction mixte
    (entier suivi d'une fraction propre, soit avec son numérateur inférieur au dénominateur)
    :)
  • le détail de la division euclidienne du numérateur par le dénominateur :)

Lorsque le résultat écrit sous forme exacte est un cosinus ou sinus de quelque chose, là
NumWorks
s'est déchaîné pour les résultats additionnels, avec :
  • représentation automatique et légendée du point associé sur le cercle trigonométrique :#tritop#:
  • cosinus associé sous forme exacte et décimale :bj:
  • sinus associé sous forme exacte et décimale :bj:

Et alors attends tu n'as pas vu les nombres complexes, ici c'est de la folie avec comme résultats additionnels proposés :
  • la représentation automatique et légendée du point associé dans le plan complexe :#tritop#:
  • le module sous forme exacte et décimale :bj:
  • l'argument sous forme exacte et décimale :bj:
  • la partie réelle sous forme exacte et décimale :bj:
  • la partie imaginaire sous forme exacte et décimale :bj:

Et non, ce n'est pas fini. Grâce au formidable travail de
NumWorks
, l'application
Calculs
gère désormais les unités, avec une toute nouvelle entrée pour t'en facilité la saisie dans la boîte à outils. De très nombreuses catégories d'unités sont présentes, de quoi couvrir l'ensemble de tes problèmes de Géométrie, Physique ou Chimie : :bj:
  • Temps
  • Distance
  • Masse
  • Intensité du courant électrique
  • Température
  • Quantité de matière
  • Intensité lumineuse
  • Fréquence
  • Force
  • Pression
  • Energie
  • Puissance
  • Charge électrique
  • Tension électrique
  • Capacité électrique
  • Résistance électrique
  • Conductance électrique
  • Induction électrique
  • Inductance
  • Superficie
  • Volume

Les unités sont notées avec le caractère tiret bas comme préfixe, que tu pourras une fois habitué saisir directement au clavier avec
shift
,
. Le menu se donne même la peine de les légender dans ta langue une fois de plus ! :bj:
Bien que toutes les combinaisons ne soient pas au menu, précisons que la calculatrice reconnaît bien l'ensemble des préfixes du système international de 1012
(
T
era)
à 10-12
(
p
ico)
! :bj:

Rien à voir avec les unités proposée sur la concurrence de milieu de gamme où si c'est pas au menu c'est foutu. Ici les unités sont de véritables éléments gérés au niveau du moteur de calcul et que tu peux donc librement intégrer à ces derniers.

Tu peux notamment sommer différentes unités compatibles, avec un résultat automatiquement converti dans l'unité jugée la plus pertinente ! :bj:

Tu as peut-être remarqué qu'il n'y avait pas de catégorie vitesse au menu, ces unités étant obtenues par un simple quotient. Les possibilités de combinaison sont infinies et permettront de gérer les unités les plus complexes ! :bj:

Si jamais l'unité déterminée automatiquement pour le résultat ne te convient pas, tu pourras parfaitement la convertir dans toute unité compatible à l'aide de l'opérateur d'affectation obtenu via
shift
x^y
! :bj:

Les unités sont tellement bien intégrées et gérées, qu'elles peuvent même accompagner les valeurs que tu stockes dans des variables. En Physique-Chimie notamment, si tu te donnes la peine de saisir chaque constante ou donnée d'une formule avec son unité, tu pourras obtenir automatiquement le résultat accompagné de son unité la plus pertinente pour rafler un maximum de points à tes exercices ! :bj:

C'est fantastique, les équivalences d'unités sont même connues de la machine, comme ici le kilogramme mètre par seconde carrée automatiquement remplacé par le Newton ! :bj:

Inversement, si l'énoncé de Physique-Chimie tente de te piéger en ne précisant de façon générique que SI
(Système International)
comme unité pour les constantes qu'il te rappelle, les formidables possibilités de combinaisons infinies de la
NumWorks
te permettront de retrouver la bonne unité ! :bj:




6) Probabilités

Go to top

L'application
Probabilités
n'est pas en reste,
NumWorks
se donne la peine d'y rajouter une nouvelle loi, la loi de Fisher. :)




7) Équations

Go to top

La
NumWorks
te permettait déjà de résoudre des équations paramétrées, c'est-à-dire faisant intervenir des variables qui ne sont pas des inconnues mais ont bien été définies avec une valeur.
Il était donc dommage à l'écran des solutions de ne pas savoir à quelle(s) valeur(s) de paramètre(s) celles-ci correspondaient.

Dans la droite lignée de sa volonté de proposer des écrans aussi complets et compréhensibles que possible,
NumWorks
te rajoute à cet écran la liste des éventuels paramètres utilisés ainsi que leurs valeurs associées. :)




8) Fonctions

Go to top

NumWorks
te permet désormais de parcourir plus rapidement tes courbes de fonctions, le déplacement du curseur s'accélérant par augmentation du pas si tu maintenant la touche fléchée enfoncée.




9) Régressions

Go to top

NumWorks
s'est également occupé de l'application
Régressions
.

Le modèle de calcul utilisé pour les régressions
Puissance
et
Trigonométrique
n'était en effet pas celui majoritairement choisi par les logiciels de Mathématiques. Si bien que la concurrence était unanime à contredire à l'unisson les résultats de la
NumWorks
dans ces cas-là :

Désormais, le nouveau modèle utilisé est bien cohérent avec la concurrence. :)




10) Conclusion

Go to top

Les bonnes choses prennent du temps et franchement cela valait le coup d'attendre; nous ne sommes absolument pas déçus aujourd'hui avec cette dernière version absolument exceptionnelle pour ta
NumWorks
, riche de fonctionnalités innovantes ou jamais vu sur un modèle à ce prix-là ! :D

Entiers, rationnels, fonctions trigonométriques et nombres complexes... à chaque fois, ce sont littéralement de mini-études que te réalise désormais
NumWorks
dans l'application
Calculs
! :bj:
Des représentations différentes qui t'amèneront à mieux comprendre chacun de ces résultats, ainsi qu'à développer ta compétence
Représenter
et passer à l'avenir plus naturellement d'une forme à l'autre. Une fonctionnalité donc d'une haute pertinence ! :bj:
On peut de plus rajouter qu'il s'agit de fonctionnalités exclusives à ce jour, ou plus précisément dans le contexte particulier de cette année 2020 avec le mode examen.
Il n'y a en effet rien d'équivalent sur les modèles concurrents, il faut y comprendre/retenir plusieurs commandes spécifiques et encore pour obtenir à chaque fois un seul des éléments de la série de résultats additionnels présentés.
De telles choses n'y étaient possibles qu'en y chargeant des programmes que nous te proposions gratuitement les années précédentes, programmes hélas bloqués par le mode examen cette année.
NumWorks
se met donc ainsi à te recréer gratuitement dans son propre mode examen des fonctionnalités équivalentes aux programmes les plus pertinents produits par la communauté pour la concurrence ces dernières années. N'oubliant pas les besoins des élèves,
NumWorks
semble ainsi être le constructeur ayant le mieux compris l'ensemble des conséquences de la réforme du mode examen ! :bj:

On apprécie également la gestion des unités directement intégrée au niveau du moteur de calcul et donc sans contrainte, avec des possibilités infinies qui ne feront que faciliter la bonne compréhension des unités ! :bj:

Et une fois encore, bravo pour le nouveau module importable
ion
pour
Python
, avec des possibilités débordant du cadre des
Mathématiques
qui seront appréciées en
Physique-Chimie
,
SNT
et
NSI
! :bj:

Toutes nos félicitations à
NumWorks
, cette version
13.1
c'est du grand art ! :bj:
Et au plaisir de la prochaine version ! ;)

Toutes ces superbes nouveautés ont toutefois un coût, la taille du
firmware
bondissant dans les
933 Kio
avec la version
13.1.0
.

Certes, aucune inquiétude à avoir pour le modèle de rentrée 2019
NumWorks N0110
avec ses
8 Mio
de
Flash
.

Mais il n'en va pas de même pour le modèle initial
NumWorks N0100
de rentrée 2017 avec seulement
1 Mio
de
Flash
. A moins de possibilités d'optimisation encore inexploitées la
NumWorks N0100
semble arriver en bout de course; elle ne pourra bientôt plus bénéficier de l'ensemble des ajouts des mises à jour à venir. :'(


Liens
:

TI-z80 COVID-19 : émulateur TI-SmartView CE gratuit pour Chrome OS

New postby critor » 28 Mar 2020, 08:40

Historiquement,
Texas Instruments
fournit ses logiciels de connectivité et d'émulation pour
Windows
et
Mac
.

Or de plus en plus d'appareils sont de nos jours munis d'un autre système d'exploitation incompatible, même les ordinateurs portables où il est de moins en moins rare de trouver
Android
ou
Chrome OS
.

Dans deux articles précédents, nous t'informions de l'intérêt de
Texas Instruments
pour ces plateformes et notamment les
ChromeBook
, avec :

Dans le contexte de la crise sanitaire actuelle,
Texas Instruments
faisait déjà de gros efforts en rendant temporairement gratuits l'ensemble de ses derniers logiciels et applications :

Texas Instruments
poursuit aujourd'hui ses gros efforts au service de la continuité pédagogique; le bêta-test de l'application d'émulation
TI-SmartView CE
pour
Chrome OS
est maintenant ouvert tout en restant gratuit ! :bj:

L'application vient visiblement chargée avec une nouvelle version système
5.4.1.0052
inconnue sur calculatrice jusqu'à ce jour.

Actuellement en version
0.1 beta
, l'application une fois installée restera fonctionnelle gratuitement jusqu'au
15 août 2020
, de quoi très largement couvrir la fin de ton année scolaire. :)

Installation
:
https://chrome.google.com/webstore/deta ... dcglmmlojo

Source
:
https://twitter.com/lisakmcleod/status/ ... 2048309249

Examens ECEBac.fr pour réussir tes ECE BAC S 2020, avec streaming !

New postby critor » 27 Mar 2020, 22:38

Avec la crise sanitaire cette année, nous ne savons pas encore si les épreuves d'
ECE
du
BAC S
en
Physique-Chimie
et
SVT
auront bien lieu cette année.

A ce jour, nous serions censés rentrer le lundi 4 Mai. Le corps enseignant se démène sans compter son temps ni son argent pour continuer à distance à te transmettre les connaissances et faire acquérir les compétences.
Sans jeter la pierre à personne soyons réalistes, l'efficacité d'un tel enseignement à distance est très variable d'un élève à un autre. Pour certains qui ont déjà disparu des radars, ce seront 5 semaines de perdues ou presque.

En conséquence il nous semble évident que l'examen du
BAC 2020
devra être adapté, d'une façon ou d'une autre.

Et les
ECE
avec justement les enseignants qui choisissent les sujets localement au niveau de chaque établissement en fonction de l'avancement des programmes nous sembleraient convenir parfaitement à la situation actuelle. ;)
Avec certes le défaut qu'ils ne concernent que la
Physique-Chimie
et
SVT
pour la série
S
, et ne constituent donc en rien une solution pour les autres matières et séries.

Le Ministre décidera, une annonce clarifiant les choses devrait intervenir d'ici le 3 avril.

Dans tous les cas de notre côté le travail a été fait, notre site
ECEBac.fr
est maintenant à jour avec la banque de sujets
2020
et plein de nouveautés, prêt à t'accompagner vers la réussite pour une 3ème année de suite ! :bj:


Le 16 mars dernier, la banque des sujets d'
ECE
du
BAC S 2020
a été publiée sur le site officiel
Eduscol
:
  • 82 sujets en
    Physique-Chimie
    (dont 26 pour la spécialité)
  • 94 sujets en
    SVT
    (dont 30 pour la spécialité)
L'épreuve d'
ECE
est notée pour 4 points sur 20, avec des coefficients de 6+6 ou 6+8 selon ta spécialité cela donne un total potentiel de 48 ou 56 points très loin d'être négligable
(c'est énorme, c'est plus que ce qui sépare un candidat admis directement suite aux épreuves écrites d'un candidat même pas convoqué aux oraux de rattrapage)
!

L'Institution a donc la gentillesse de te publier à l'avance directement les sujets qui vont t'être posés, mettant ainsi tous les candidats à égalité de chances ! :bj:

Chaque académie est censée choisir 20 sujets dans cette banque pour chaque matière, puis envoyer la liste des sujets retenus à ton lycée le 4 Mai.

Les enseignants de ton lycée doivent alors choisir dans cette dernière liste de 20 sujets lesquels ils organisent pour les épreuves, en fonction bien sûr de l'avancement du programme, des TPs déjà réalisés et du matériel déjà manipulé.

L'année dernière, la calculatrice graphique personnelle était interdite aux épreuves.
Pour les sujets nécessitant une calculatrice, on te fournissait celle de l'ordinateur ou sinon une calculatrice collège.

Nouveauté cette année, tous les sujets de
Physique-Chimie
autorisent ta calculatrice graphique personnelle, à la seule condition de la passer en mode examen ! :bj:

Pour la
SVT
rien n'est hélas précisé dans les documents publiés, ni interdiction ni autorisation. En même temps, il n'y a que 2 sujets qui mentionnent la nécessité d'une calculatrice.

La publication officielle des sujets n'est toutefois pas sans défauts:
  • pas de vue d'ensemble puisque les sujets sont répartis sur 8 pages à charger !
  • ils prennent de plus chacun la forme d'un fichier
    .zip
    (dossier compressé)
    qui ne sera pas toujours facile à visualiser, notamment sur smartphone !
  • pas de lien de téléchargement global; tu dois donc te taper 120 à 150 téléchargements !
  • l'ensemble de ces téléchargements flirte avec la capacité d'un CD
    (plusieurs centaines de mégaoctets)
    puisque plusieurs sujets sont accompagnés de vidéos, ce qui est déjà pénible à télécharger avec la bande passante allouée par le site officiel. Cela pourra également être lourd pour repartager la banque entre tes différents appareils pour l'avoir toujours à disposition
    (ordinateur, tablette, smartphone)
    , ainsi que pour la partager avec tes camarades.
  • et c'est sans compter tout le travail d'extraction et classification qui en découle car une bonne 100aine de dossiers nommés avec de simples numéros ne va pas être d'une grande aide niveau accessibilité...

Pour t'accompagner vers la réussite et te permettre dès cette semaine de commencer à préparer ton épreuve dans des conditions optimales, nous mettons à ta disposition , notre site de référence pour les épreuves d'
ECE
du
BAC S
.

Il a été conçu dès 2018 en réponse aux problèmes précédents, à savoir avec les objectifs principaux :
  • d'offrir une vue d'ensemble
  • de permettre de télécharger les fichiers aussi bien individuellement que globalement
  • de permettre de prendre connaissance de chaque contenu aussi facilement et rapidement que possible
  • de fournir un maximum de solutions gratuites dans la mesure du possible
  • de fonctionner aussi bien sur ordinateur que sur smartphone

nous permet de mutualiser notre travail titanesque de récupération/extraction/lecture/énumération/classification réalisé sur les sujets ces 10 derniers jours.

Il prend la forme d'annales numériques enrichies avec une dose d'interactivité et de dynamisme.

D'une part, le site te permet d'avoir une vue d'ensemble des sujets, les listant tous sur une même page avec pour chacun :
  • son numéro public
  • la disponibilité d'une ou plusieurs corrections
  • son titre
  • une précision sur sa spécificité lorsque le sujet est décliné en plusieurs versions
  • la mention obligatoire ou spécialité
  • la partie du programme concernée
A l'aide des boutons en haut tu peux basculer entre les sujets de Physique-Chimie et de SVT, faire le choix de lister les sujets obligatoires ou de spécialité ou encore tous les sujets, et trier selon le critère de ton choix, notamment par partie du programme concerné.

C'est cette année la liste des sujets 2019 qui est affichée par défaut mais, nouveauté 2019, tu as maintenant la possibilité de revenir aux listes des années précédentes.


Une fois sur la page dédiée au sujet choisi, tu retrouveras :
  1. un bloc reprenant les informations de la liste avec cette fois-ci l'affichage complet de la matière et de la partie du programme, ainsi que la ou les sources des fichiers disponibles
  2. un bloc listant et identifiant l'ensemble des fichiers du sujet choisi :)
  3. un bloc listant et liant les corrections disponibles :bj:
  4. un bloc listant les logiciels nécessaires pour le sujet choisi, avec des liens de téléchargement gratuit pour t'entraîner comme à l'examen :bj:
  5. un bloc de commentaires pour publier tes questions/réponses/informations sur ce sujet avant, pendant et même après ton épreuve :bj:

Tu as donc le choix de cliquer individuellement sur un fichier pour le télécharger/ouvrir dans ton navigateur, ou bien de récupérer l'archive complète du sujet comme sur le site officiel.

Pour cette session
2020
nous avons travaillé dur sur nombre de nouveautés toujours dans l'esprit initial du site :
  • les tailles des fichiers sont maintenant toutes précisées, que tu saches à quoi t'attendre avant téléchargement :bj:
  • les documents bureautiques de la liste sont maintenant décrits avec des étiquettes reprenant leurs métadonnées
    (auteurs, nombre de pages, date d'enregistrement...)
    :)
  • les durées des fichiers audio/vidéo sont également indiquées
  • plus besoin de télécharger les gros fichiers audio
    .mp3/wav
    et vidéo
    .mp4
    au complet pour les ouvrir, nous t'avons mis en place un serveur de
    streaming
    qui te permettra une consultation immédiate sans téléchargement ! :bj:
  • les images
    .bmp
    de certains sujets sont enfin visualisables sans téléchargement :)


Notons que les listes de fichiers ont été enrichies de quelques améliorations par rapport à la version officielle :
  • disponibilité d'une version
    .mp4
    visualisable en ligne sans téléchargement pour les vidéos de certains sujets utilisant d'autres formats
    (
    .avi/mpg/mov
    )
  • disponibilité d'une version
    .mp3
    écoutable en ligne sans téléchargement pour les fichiers audio de certains sujets utilisant un autre format
    (
    .mp2
    )
  • disponibilité d'une version
    .pdf
    plus facilement visualisable pour chaque document bureautique présent
  • disponibilité d'une version
    .png
    visualisable directement dans le navigateur pour chaque image
    GIMP .xcf
  • certains énoncés ont été en prime diffusés dans une version non finalisée qui a été incluse; il pourra être éclairant de voir quelle(s) modification(s) les concepteurs ont apportée(s) en dernier

Attention nous ne concevons pas de corrigés, et pour des épreuves organisées localement il n'est pas dans les habitudes des enseignants concernés d'en diffuser non plus.

C'est à toi de concevoir tes propres corrigés pour les nouveaux sujets 2020 et même si tu veux de nous les proposer sur le site en question, ce sera justement l'occasion d'échanger dans le bloc commentaires pour les parfaire collectivement, l'union faisant la force. ;)
Toutefois les nouveaux sujets sont minoriaires. Une bonne partie sont basés sur des sujets tombés en 2019 ou 2018, et dans ces cas-là nous t'avertissons que des sujets simimaires disposent de corrigés qui peuvent potentiellement convenir après quelques ajustements et te les lions.
C'est très loin d'être négligeable : ;)
  • en
    Physique-Chimie Obligatoire
    , 39 sujets sur 56
    (69,6%)
    sont basés sur des sujets corrigés des années précédentes :bj:
  • en
    Physique-Chimie Spécialité
    , ce sont 14 sujets sur 26
    (53,8%)
    qui sont donc potentiellement déjà corrigés :bj:
  • en
    SVT Obligatoire
    , 43 sujets sur 64
    (67,2%)
    :bj:
  • et en
    SVT Spécialité
    , 21 sujets sur 30
    (70%)
    :bj:
En gros, environ 2/3 des sujets sont potentiellement déjà corrigés ! :bj:

Bonne réussite à toi avec , le site sur-mesure qui t'accompagnera jusqu'à la porte de ta salle de TP ! ;)

Lien
:

TI-z80 Formation en ligne nouveau Python 83 Premium CE - 1er avril

New postby critor » 27 Mar 2020, 17:03

12379Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à l'application
Python
de ta
TI-83 Premium CE Edition Python
.

Elles prendront la forme de 4 modules importables supplémentaires :
  • ti_plotlib
    , une bibliothèque graphique conformément aux programmes de
    Physique-Chimie
    ,
    SNT
    et
    NSI
    , tout en permettant également nombre d'applications en
    Mathématiques
    ! :bj:
  • ti_system
    , pour enfin pouvoir interagir avec les variables hors application
    Python
    ; enfin l'application
    Python
    pourra véritable servir à résoudre des problèmes et non plus à coder un truc dans un coin ! :bj:
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)

Malheureusement, dans le contexte de la crise sanitaire actuelle, tous les salons éducatifs lors desquels tu aurais pu découvrir ces nouveautés à l'avance sont annulés les uns après les autres, ou à défaut reportés de plusieurs mois. :'(

Mais
Texas Instruments
tient compte de ce contexte difficile, et t'invite en conséquence à venir découvrir tout ça en avant-première ce
Mercredi 1er avril
lors d'une formation en ligne, de
18h30
à
20h
! :bj:

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

Casio COVID-19: modification tournée pédagogique Casio avril 2020

New postby critor » 27 Mar 2020, 14:09

Dans sa prochaine mise à jour gratuite pour
Graph 35+E II
et
Graph 90+E
,
Casio
va rajouter de formidables possibilités graphiques à son application
Python
sous la forme de deux modules importables :
  • matplotl
    (en fait un
    matplotlib.pyplot
    )
  • turtle
Les fonctions implémentées sont de plus conformes aux modules
Python
de même nom déjà existants sur d'autres plateformes, si bien que les scripts conçus pour ta calculatrice
Casio
seront compatibles ! :bj:

Afin de te les faire découvrir en avant-première
Casio
te proposait un formidable événement, la tournée pédagique, au cours duquel le constructeur se proposait de faire le tour de France avec des étapes dans pas moins de 18 villes en avril et mai 2020. :D

Dans le contexte de la crise sanitaire qui nous touche actuellement, les étapes du mois d'avril 2020 sont annulées : :'(
  • Mercredi 8 avril :
    Bordeaux, Dijon, Grenoble
  • Mercredi 29 avril :
    Créteil, Nice, Reims
  • Mercredi 6 mai :
    Clermont-Ferrand, Mulhouse, Rouen, Toulouse
  • Mercredi 13 mai :
    La Rochelle, Nancy, Rennes, Versailles
  • Mercredi 27 mai :
    Lille, Lyon, Nantes, Paris

Toutefois, en remplacement
Casio
te propose ce mois d'avril de découvrir ces mêmes nouveautés lors de formations en ligne rajoutées à son calendrier : :bj:
  • Mercredi 1er avril - 14h-14h45 :
    mises à jour
    Graph 90/35+E II
    ; bibliothèques graphiques
    Python
    matplotlib
    et
    turtle
  • Lundi 6 avril - 14h-15h30 :
    tournée pédagogique en ligne; atelier collège
  • Mercredi 8 avril - 14h-16h :
    tournée pédagogique en ligne; atelier lycée
  • Mercredi 15 avril - 14h-15h30 :
    tournée pédagogique en ligne; atelier collège
  • Vendredi 17 avril - 14h-16h :
    tournée pédagogique en ligne; atelier lycée
Pour toute participation à la tournée pédagogique,
Casio
te proposait de repartir avec l'une des calculatrices mises à ta disposition lors de la formation. Et bien précisons que cette offre est maintenue de le cadre de la tournée pédagogique en ligne, la calculatrice en question sera expédiée à la fin du confinement. :D


Liens
:


Source
:
https://www.casio-education.fr/formations/atelier

TI-z80 Sonic vs Mario, l'affrontement ultime sur TI-83 Premium CE !

New postby critor » 26 Mar 2020, 14:41

Années 1980 et 1990, la guerre des consoles de jeux fait rage.

D'un côté nous avons
Nintendo
et avec la même mascotte depuis 1981, le célèbre
Jumpman
renommé
Mario
dès 1982.

De l'autre nous avons
Sega
qui n'a pas hésité à congédier plusieurs fois les mascottes qu'elle lui opposait :
  • Opa Opa
    le vaisseau ailé en 1985
  • Alex Kidd
    l'enfant-singe de 1986 à 1990
  • et ce dernier jugé bizarrement à l'époque trop japonais pour un succès international, se voit remplacé à partir de 1991 par
    Sonic
    le hérisson

En 2001,
Sega
jette l'éponge et se retire du marché des consoles de jeux, interrompant brutalement l'affrontement de
Mario
et
Sonic
.

12303Des regrets ? Estimes-tu que
Mario
ou
Sonic
n'avait pas dit son dernier mot ?

Et bien pour ensoleiller ta fin de semaine à l'ombre, te propose un nouveau niveau perso pour
Oiram CE
, le moteur de jeu
Mario-like
de ta
TI-83 Premium CE
. :D

Sonic vs Mario
te propose de réunir nos deux mascottes dans un dernier combat. A part qu'ici c'est un
Sonic
géant que
Mario
Oiram
va devoir affronter...

Sonic
ou
Mario
, qui mérite la victoire ? ;)

Pour fonctionner correctement,
Oiram CE
a besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de récupérer et transférer leur fichier. :)

Téléchargements
:

-
Search
-
Featured topics
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
Comparaisons des meilleurs prix pour acheter sa calculatrice !
12
-
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 
-
Stats.
388 utilisateurs:
>370 invités
>12 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)