La question du jour.
j'ai demandé à un générateur de code fait par l'I.A. si elle pouvait comprendre une phrases simple et générer une erreur. De ce fait voici comment l'erreur ressemble. Je ne dis pas qu'elle n'est pas capable de travailler et de faire de la programmation. Disons que j'ai donné toutes les chances à l'I.A. de surpasser les connaissances que j'ai si j'avais seulement 5 minutes pour faire quelque choses. La réponse serait j'aurais moins 50% de vrai malgré ce qu'elle laisse comme trace. Elle laisse aussi des problèmes et une forme d'incompréhension qui laisse aussi le choix des "templates" pourqu'elle choisissent un "template" de Type RUST qui n'est pas tout à fait adapter.
Note final.
Si le professeur expliquent qu'il veut un calcul de Fibonacci et de voir ou est le résultat. Oui 40% de la pratique est là et elle comprend qu'il s'agit de calculer du Fibonacci. Mais c'est elle en quoi ça implique faire du Fibonacci.
La question qui tue.
La fameuse commande où phrase demandé à l'I.A. consiste à demander:
"Generate a 96 bit counter to produce Fibonacci sequence from the counter and to output to stdout"
En français : "Génère un compteur supportant 96 bit de comptage et me rapporter le le Fibonacci à partir du résultat du compteur et me l'affiché à l'écran."
Liberté de décompte.
De un, je n'ai rien dit du compteur comme étant libre de foi. Un compteur peut commencer du 96ième bit ( ou en décimal 79228162514264337593543950336 ) et descendre à 0. C'est beaucoup plus sécuritaire, mais là encore le code de l'I.A n'indique pas si il s'agit d'une augmentation du compteur ou est un compteur réductionniste.
à la ligne 53 est la grosse déception de comment elle passe de 96bit un enjeu d'espace à 94 ( après avoir touché le 96iemes bit ou nombre je descend de 2 autres bit et re-compte le Fibonacci). Une très grosse erreur. Elle a donc compris faire un compteur de 96bit et y mettre le Fibonacci de même.
Elle a compris de le compteur était en 96 bit. Moi 96 bit c'est 3 x 32 bit et non 3 x 64 ou 192 bit. Aviez vous déjà lu un roman d'enfant avec l'ordinateur qui voulait des raisonement super complexe et qui n'est pas capable de faire une multiplication de nombre cohérente. De plus ce roman jeunesse produit les résultats à l'imprimante en plus.
Et voici l'erreur en question "store the Fibonacci number as three 64-bit part". Oui elle comprend qu'un Fibonacci c'est gros, mais plutôt tout est en 96 bit et le nombre ou niveau de Fibonacci pouvant entrer dans un 96 bit est un niveau 140. ou au niveau 139 le Fibonacci en cours est à 50095301248058391139327916261 encore trop petit pour 2^96.
Donc ici le Fibonacci et sont format d'impression est bel et bien "%llu%016llu%016llu" un "%llu" c'est 64 bit. Alors il y a beaucoup d'espace et c'est avoir migré un Template Rust de 32 bit à 64 bit et oublier d'ajuster le calcul qui doit être à 96 bit.
Personnellement, un Fibonacci de 96bit ou Fib(79228162514264337593543950336) est trop gros même sur Python. Pour l’exercice et avoir la paix d'esprit pour la représentation numérique de nombre à un chiffre de sortie j'ai utilisé math.set_int_max_str_digits(7200) pour dépasser la représentation de 3400 caractères par défaut et avoir le Fibonacci Fib(16384) et c'est très gros.
Voici l'expansion binaire versus le niveau Fibonacci escompté. Utilisé le nombre Fib(X) ou X est un nombre entre 1 et 16384 donne une représentation binnaire extraite au logarithme de la base de 2. Naturellement il y a des virgules et les conditions ou la virgule apparaît, alors le nombre Fibonacci est stocké ou interprétable avec un bit de plus. Utilisant:
ArrayBin=list()
for i in range( len(ArrayList) ):
if i == 0 :
ArrayBin.append( 0 )
elif i == 1:
ArrayBin.append( 1 )
elif i == 2:
ArrayBin.append( 1 )
elif i == 3:
ArrayBin.append( 2 )
else:
xBin = round( math.log( ArrayList[i], 10 ) / math.log( 2 , 10 ) )
if float( xBin ) < float( math.log( ArrayList[i], 10 ) / math.log( 2 , 10 ) ):
ArrayBin.append( xBin+1 )
else:
ArrayBin.append( xBin )
return ArrayBin
Graphique à l'appui.
Ce qu'il faut savoir.
Que le Fibonacci Fib(16383) entre dans 11373 bit et interpolant tous les nombres inférieur à Fib(16383) nous pouvons faire une règle d'équation dans lequel lorsqu'un nombre est demandé entre 1 et 16383 de faire si X est un nombre entre 1 et 16383 :
à la forme AX+C :
1.44051701398048008441 * X donne le nombre de bit nécessaire et relate que l'équation de Fibonacci pourrait demander une équation supplémentaire pour la stocker. Ici j'ai demandé de l'affiché à l'écran, mais en fait il doit y avoir un stockage pour le calcul. ici le nombre final tient dans 1.5 kilo Octets.
le code est le suivant et est disponible en ligne:
Le code n'est non plus pas possible à compiler. Utilisant le "NASM" pour "net-wide assembler" vous pouvez utiliser "SAMS" sous "linux" et installer "NASM" aussi requis vous devez allé dans les options de configurations et coché pour le support 64 bit. Vous pouvez aussi utiliser "TutorialsPoint" un portail d'aide à la programmation mais l'erreur reste la même.
Encore une histoire de "template" RUST qui n'est pas bien calibré il est en 32/64 bits le code et ne supporte pas les saut simples. D’ailleurs il n'y a que ARM et le RISC-V qui supporte les saut simple voir un "goto". Plusieurs autre interface web et Assembler pour 32bit et x86_64 sont disponible mais ne supporte pas l'adressage à la pile ou BSS (Boundary Stack Segment)
Si le code n'est plus disponible :
section .data
fmt db "%llu%016llu%016llu", 10, 0 ; format for printing three 64-bit parts (high, mid, low) with newline
section .bss
; We'll store the 96-bit Fibonacci numbers as three 64-bit parts:
; fib_n_minus_2: 96-bit number (high, mid, low)
; fib_n_minus_1: 96-bit number (high, mid, low)
; fib_n: current Fibonacci number (high, mid, low)
fib_n_minus_2_high resq 1
fib_n_minus_2_mid resq 1
fib_n_minus_2_low resq 1
fib_n_minus_1_high resq 1
fib_n_minus_1_mid resq 1
fib_n_minus_1_low resq 1
fib_n_high resq 1
fib_n_mid resq 1
fib_n_low resq 1
section .text
global main
extern printf
main:
; Initialize fib(0) = 0
mov qword [fib_n_minus_2_high], 0
mov qword [fib_n_minus_2_mid], 0
mov qword [fib_n_minus_2_low], 0
; Initialize fib(1) = 1
mov qword [fib_n_minus_1_high], 0
mov qword [fib_n_minus_1_mid], 0
mov qword [fib_n_minus_1_low], 1
; Print fib(0)
mov rdi, fmt
mov rsi, [fib_n_minus_2_high]
mov rdx, [fib_n_minus_2_mid]
mov rcx, [fib_n_minus_2_low]
xor rax, rax
call printf
; Print fib(1)
mov rdi, fmt
mov rsi, [fib_n_minus_1_high]
mov rdx, [fib_n_minus_1_mid]
mov rcx, [fib_n_minus_1_low]
xor rax, rax
call printf
; We'll produce next 94 Fibonacci numbers (total 96)
mov rcx, 94
fib_loop:
; fib_n = fib_n_minus_1 + fib_n_minus_2 (96-bit addition)
; Load fib_n_minus_1 parts
mov rax, [fib_n_minus_1_low]
mov rbx, [fib_n_minus_1_mid]
mov rdx, [fib_n_minus_1_high]
; Add fib_n_minus_2_low
add rax, [fib_n_minus_2_low]
; Add fib_n_minus_2_mid with carry
adc rbx, [fib_n_minus_2_mid]
; Add fib_n_minus_2_high with carry
adc rdx, [fib_n_minus_2_high]
; Store fib_n
mov [fib_n_low], rax
mov [fib_n_mid], rbx
mov [fib_n_high], rdx
; Print fib_n
mov rdi, fmt
mov rsi, rdx
mov rdx, rbx
mov rcx, rax
xor rax, rax
call printf
; Move fib_n_minus_1 to fib_n_minus_2
mov rax, [fib_n_minus_1_low]
mov rbx, [fib_n_minus_1_mid]
mov rdx, [fib_n_minus_1_high]
mov [fib_n_minus_2_low], rax
mov [fib_n_minus_2_mid], rbx
mov [fib_n_minus_2_high], rdx
; Move fib_n to fib_n_minus_1
mov rax, [fib_n_low]
mov rbx, [fib_n_mid]
mov rdx, [fib_n_high]
mov [fib_n_minus_1_low], rax
mov [fib_n_minus_1_mid], rbx
mov [fib_n_minus_1_high], rdx
loop fib_loop
; Return 0
mov eax, 0
ret
Bien sur les compagnie D'I.A. promette d'engagé plus de 8000 autres travailleurs, mais est-ce vraiment des travailleurs qui sont nécessaire. Noté que même avec l'effort de Karl Malenfant de ne pas atteindre son but à engagé plus de travailleur, mais n'est jamais vraiment sortis la solution. À mon avis Kurt Cobain est plus réaliste en citant dans 2001 Space Odyssey, incluant un X-IA qui à créer HAL est aussi problématique de ce qu'il est en train de ce créer. Un HAL qui ment à sa façon et cherche probablement Julia.