PureBasic

Bonjour, j'ai développé une sorte de complément virtuel (pour l'instant) d'un microprocesseur.
J'ai appelé cela un introprocesseur.
Il s'agit d'un fichier à stocker sur un supporte rapide, ou une ROM rapide d'accès.
C'est une sorte de ROM à double adressage : (je ne sais pas si cela existe physiquement)
On y rentre un nombre considéré comme un résultat dans la première adresse, et l'on teste si un deuxième nombre est facteur du premier en le rentrant en tant que deuxième adresse. Le resultat obtenu en donnée est un '0' ou un '1'.

C'est un petit pas intermédiaire entre l'ordinateur traditionnel et l'ordinateur quantique, puisque cela permet, à partir d'un résultat, de retrouver des tas de possibilités ayant permis d'atteindre ce résultat.
De plus, on peut savoir, dans certaines limites, si un nombre est premier.

Le principe est simple : Au lieu de calculer pour chaque nombre s'il est premier et quels sont les facteurs le composant à chaque fois, on calcule dans une fichier tous les facteurs de chaque nombre sous une forme la plus simplifiée possible... des 0 et des 1.

Exemple :
12 peut être représenté par 000010|111110. Ça se lit de gauche à droite. Le 1er 0 correspond au facteur '1', le 2ème au facteur '2', etc...
Si on trouve un '0', alors, le facteur correspondant permet de recomposer le nombre. Toute la partie droite du nombre, soit N/2 est inutile, puisqu'elle ne contient qu'au mieux un '0' correspondant au nombre lui même.

Et la logique pour recomposer cette sorte de crible mathématique est :
1 2 3 4 5 6 7 8 9 (adresse facteurs)

0 0 0 0 0 0 0 0 0 | 00 (adresse de résultat)
0 1 1 1 1 1 1 1 1 | 01
0 0 1 1 1 1 1 1 1 | 02
0 1 0 1 1 1 1 1 1 | 03
0 0 1 0 1 1 1 1 1 | 04
0 1 1 1 0 1 1 1 1 | 05
0 0 0 1 1 0 1 1 1 | 06
0 1 1 1 1 1 0 1 1 | 07
0 0 1 0 1 1 1 0 1 | 08

Regardez bien chaque colonne (verticale), et vous verrez que cela ressemble à des fréquences.
Un pro en algorithmique peut probablement casser les nombres premiers...

Vous trouverez un code source d'application ici :
http://www.lumene.fr/Introprocesseur_Virtuel_16bits.zip

Il faut d'abord lancer le calcul de la ROM virtuelle une bonne fois pour toute, et ensuite, l'introprocesseur virtuel peut être utilisé.
Ceci n'est qu'un code source test à améliorer.

Comme dirait Morpheus dans Matrix : "Je ne peux que te montrer la voie, Neo !"
Bref, si quelqu'un comprend l'intérêt de ce code source et la théorie, il peut probablement parvenir à fabriquer des merveilles qui seront plus puissantes que l'ordinateur de météo-france, et peut-être, donc, faire avancer la science à pas de géants.

je n'ai pas compris grand chose mais suis captivé par ce genre de topic.
Et comme qui dirait, je cite 'moi-même' : "Ce qui me dépasse me fascine".

En fait, j'ai fait ce programme/topic pour deux raisons :

1) La partie mathématique est un crible de mon cru pour trouver les nombres premiers, et les paires de facteurs composants les nombres pairs ou impairs.

Exemple :
Je peux résumer le nombre 12 par 1x12, 2x6, 3x4.
Ceci apparaît dans mon crible sous la forme :
12,11,10,9,8,7,6,5,4,3,2,1
0,1,1,1,1,1,0,1,0,0,0,0
On remarque ici que là où il y a des zéros, cela correspond avec les facteurs cités plus haut. (Attention, ce n'est pas du binaire !)

Si vous regardez bien comment est fait mon crible, vous comprendrez qu'il existe un algorithme tout simple pour le résumer, et que je n'arrive pas à le formuler.
Inutile de dire que celui qui le formule risque juste d'avoir le prix Nobel.

Pour résumer l'affaire, si je regarde chaque ligne, j'ai dans l'ordre des nombres entiers Naturels, résumés sous formes de paires de facteurs.
Mais si je regarde chaque colonne, je me rend compte que quelque chose de répétitif se passe. (Vous pouvez vérifier avec de grand nombres, ça marche toujours)

2) Le principe de la partie programmation est simple, mais il peut être largement amélioré.

Sachant qu'un homme calcule très lentement des opérations sur des grands chiffres par rapport à une autre homme qui aurait appris par coeur les résultats (si si, ça existe des gens comme ça !), j'ai pensé que c'était la même chose pour un ordinateur.
J'ai pensé qu'il est plus rapide de sortir tous les facteurs d'un grand nombre à partir d'une mémoire à accès rapide, plutôt que de calculer 1 à 1 tous les facteurs d'un nombre, ce qui impliquerait pas mal de divisions ou de modulos.

Donc, le principe de mon programme est de précalculer un maximum de facteurs de nombres pour éviter de refaire ces calculs.

A partir de là, si on pose la question à mon programme :
63277 est t'il premier, la réponse est immédiate.
De même, si je veux savoir si 63277 est divisible 834, je le sais de suite.
Enfin, si je veux connaitre toutes les paires de facteurs qui permettent de retrouver ce nombre, j'en obtient la liste tout de suite.

Imaginez un processeur 128 bits qui doit faire 20000 divisions avec des gros chiffres... je suis sûr que c'est plus rapide de faire plutôt 20000 vérifications dans une mémoire aussi rapide que le processeur !

DjPoke a écrit :Inutile de dire que celui qui le formule risque juste d'avoir le prix Nobel.

faudrait déjà qu'il existe

DjPoke a écrit :J'ai pensé qu'il est plus rapide de sortir tous les facteurs d'un grand nombre à partir d'une mémoire à accès rapide, plutôt que de calculer 1 à 1 tous les facteurs d'un nombre

Comme on dit dans ces cas là : "thanks captain obvious".

Découvert en 2008, le plus grand nombre premier connu est le nombre premier de Mersenne « 2^(43 112 609)-1 », qui comporte près de 13 millions de chiffres en écriture décimale

courage pour stocker tout ça. car si j'ai bien compris, avec ton "crible" il faut un tableau de 13 millions par 13 millions, ce qui donne 1,69*10^14.