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: Select all
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)
script
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
by 
Bientôt les premières épreuves de spécialité du Baccalauréat 2023, dès le lundi 20 Mars pour la Métropole.
