Depuis la rentrée 2020, NumWorks te sort chaque mois une coque collector en édition limitée pour votre calculatrice. Si vous êtes chanceux(se) et avez su vous montrer assidu(e), alors vous devriez avoir pu vous constituer une formidable collection. En plus des éditions spéciales ci-contre, voici les coques du mois par ordre chronologique : 
Since the beginning of the 2020 school year, NumWorks has been releasing a limited edition of cases for your calculator every month. If you're lucky enough, you may have built up a great collection. Here are the cases of the month in a chronological order (without forgetting the special editions) :
Le mois dernier, NumWorks avait choisi de célébrer le 14 Février sur sa coque. Pour la reconduction de l'évément ce mois-ci, NumWorks choisit de célébrer le 14 Mars, ou en Anglais Mars 14 soit 03/14, journée du nombre π et journée internationale des Mathématiques !Pour l'occasion, la nouvelle coque pour ta NumWorks se pare des
$mathjax$3+34\times 8\times 3=819$mathjax$
premières décimales de π que tu pourras ainsi consulter rapidement à tout moment !
Vu que ces décimales sont de plus gravées en utilisant la police de la calculatrice, le comble serait bien sûr qu'elles eussent justement été calculées sur une NumWorks.Selon que l'on utilise l'application Python ou pas, notre calculatrice NumWorks nous sort une écriture décimale du nombre π avec 9, 13 ou 15 décimales.
Ce n'est bien évidemment qu'une approximation, puisque π n'est pas un nombre décimal. C'est-à-dire qu'il est impossible de l'écrire de façon exacte en écriture décimale, une telle écriture nécessitant une infinité de chiffres après la virgule. Tentons donc d'obtenir une bien meilleure approximation de π.
Plusieurs algorithmes ou formules de calcul existent. Optons pour le développement en série entière de la formule de Machin datant de 1706, méthode qui a l'avantage d'offrir un bon compromis entre nombre d'opérations et vitesse de convergence :
$mathjax$\pi=4\left(4arctan \frac{1}{5}-arctan\frac{1}{239}\right)$mathjax$
Faut-il encore développer un script qui soit capable d'effectuer ces opérations sur des nombres à plus de 16 chiffres significatifs. On peut par exemple représenter de tels nombres par une suite de chiffres, que l'on peut coder sous forme de liste, tuple, chaîne de caractères ou tableau d'octets. Optons pour le tableau d'octets. Ce n'est certes pas le plus performant, mais nous souhaitons avoir beaucoup de décimales et ce choix a l'avantage de permettre une économie maximale sur la consommation de la mémoire de tas (heap), de loin le facteur le plus limitant de la NumWorks. Reste alors encore à programmer les différentes opérations chiffre à chiffre comme tu le faisais à l'école primaire (ici l'addition, la soustraction, la multiplication, la division... et la fonction arctangente que tu n'avais pas encore vue à l'époque).
Et c'est chose faite :
- Code: Tout sélectionner
from kandinsky import draw_string
def bdf_new(d0, nd):
bdf = bytes((d0,)) + bytes(nd - 1)
return bdf
def bdf_add(bdf1, bdf2):
c = 0
bdfr = b''
for i in range(len(bdf1) - 1, -1, -1):
v = bdf1[i] + bdf2[i] + c
if i:
c = v >= 10
if c:
v -= 10
bdfr = bytes((v,)) + bdfr
return bdfr
def bdf_sub(bdf1, bdf2):
c = 0
bdfr = b''
for i in range(len(bdf1) - 1, -1, -1):
v = bdf1[i] - bdf2[i] - c
if i:
c = v < 0
if c:
v += 10
bdfr = bytes((v,)) + bdfr
return bdfr
def bdf_times(bdf, k):
c = 0
bdfr = b''
for i in range(len(bdf) - 1, -1, -1):
v = k*bdf[i] + c
if i:
c = v // 10
if c:
v -= 10 * c
bdfr = bytes((v,)) + bdfr
return bdfr
def bdf_div(bdf, k):
c = 0
bdfr = b''
for i in range(len(bdf)):
x = 10*c + bdf[i]
c = x % k
bdfr += bytes((x // k,))
return bdfr
def bdf_ataninv(d, n):
bdf0 = bdf_new(0, n)
bdf1 = bdf_new(1, n)
k1 = d
k2 = 1
d2 = d ** 2
bdfr = bdf0
bdfd = bdf_div(bdf1, k1)
while bdfd != bdf0:
if k2 % 4 == 3:
bdfr = bdf_sub(bdfr, bdfd)
else:
bdfr = bdf_add(bdfr, bdfd)
k1 *= d2
k2 += 2
bdfd = bdf_div(bdf1, k1 * k2)
return bdfr
def bdf_pi(n):
return bdf_times(bdf_sub(bdf_times(bdf_ataninv(5, n), 4), bdf_ataninv(239, n)), 4)
def print_bdf(bdf, l):
s = str(bdf[0]) + '.'
for d in bdf[1:]:
if len(s) == l:
print(s)
s = ''
s += str(d)
if len(s):
print(s)
def draw_bdf(bdf, l):
y = -3
s = str(bdf[0]) + '.'
for d in bdf[1:]:
if len(s) == l:
draw_string(s, 0, y)
s = ''
y += 14
s += str(d)
if len(s):
draw_string(s, 0, y)
def demo(shell=True, big=True):
if shell:
bdfpi = bdf_pi(big and 359 or 687)
print_bdf(bdfpi, big and 30 or 43)
else:
bdfpi = bdf_pi(511)
draw_bdf(bdfpi, 32)
# shell in big font
demo(1, 1)
# graphic (big font)
#demo(0)
# shell in small font
#demo(1, 0)
La formidable dernière itération N0120 du modèle en profite une fois de plus pour nous démontrer sa puissance astronomique dans le monde des calculatrices graphiques, avec :- 16.6 secondes pour l'affichage de 358 décimales de π sur la console en grande police
- 38.4 secondes pour l'affichage de 510 décimales de π sur l'écran graphique (grande police obligatoirement)
- 1 minute 23.1 secondes pour l'affichage de 686 décimales de π sur la console en petite police
Pour tenter de gagner cette coque c'est très simple ; il te suffit sur le réseau social de ton choix de :
Voici les adresses associées, et n'hésite pas à participer sur les différents réseaux pour maximiser tes chances :
- t'abonner au compte du constructeur
- aimer la publication
- partager la publication sur le même réseau (retweet, story, ...)
- répondre en mentionnant 1 ami (tag, identification, ...)
Voici les adresses associées, et n'hésite pas à participer sur les différents réseaux pour maximiser tes chances :
- Twitter : (1 coque - jusqu'au 31 Mars)
France
Etats-Unis - Facebook : (1 coque - jusqu'au 31 Mars)
France
Etats-Unis
Pays-Bas
Portugal - Instagram : (jusqu'au 31 Mars)
France (10 coques)
Etats-Unis (1 coque)
Pays-Bas (1 coque)
Portugal (1 coque)
