Discussion :

[Rekin85]

Bonjour à tous (surtout aux anciens...)

Promis, juré, craché, j'ai consulté la FAQ auparavant.
Ma question est simple : au temps de D7 et des compilateurs 32 bits, pour insérer des portions de code en ASM, il suffisait de les placer entre les balises asm...end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
asm
    code asm
    code asm
    .....
end;

Ceci est-il encore possible avec les versions 64 bits de Delphi ?

Merci à tous.

[XeGregory]

Oui, c’est encore possible… mais pas en 64 bits.

Seul le compilateur Win32 accepte encore l’assembleur inline.

Le compilateur Win64 impose soit du Pascal pur, soit des modules ASM externes.

https://docwiki.embarcadero.com/RADS..._Assembly_code

[anapurna]

salut

Oui, c’est encore possible… mais pas en 64 bits.

Seul le compilateur Win32 accepte encore l’assembleur inline.

Le compilateur Win64 impose soit du Pascal pur, soit des modules ASM externes.

https://docwiki.embarcadero.com/RADS..._Assembly_code

Bien sur que si tu peux faire de l'asm inline en 64
la seule contrainte c'est que la méthode entière doit être en asm

Tun ne peut pas faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
Function Test : Integer 
Begin 
  METHODE1;
  ASM
    ... 
  End;
End;

Par contre tu peut Faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Function Test : Integer 
ASM
  ...
  Call METHODE1;
    ... 
End;

[ShaiLeTroll]

Et comme évoqué dans ce sujet assembleur: conversion d'un Little Endian (64 bits) en Big Endian en mode 64 bits, tu peux avoir un ASM différent selon la cible

register sera aussi sans effet en Windows 64Bits, tout est en convention d'appel passe en x64
Pour les autres OS et ARM, là ça doit se compliquer.

Prévoyer une fonction avec directive, const est préférable à var dans ce cas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
function ByteSwap(const a : Int64) : int64;
asm
{$IFDEF CPUX64}
  BSWAP RCX;
  MOV RAX, RCX;
{$ELSE}
  MOV EDX,[EBP+$08];
  MOV EAX,[EBP+$0C];
  BSWAP EAX;
  BSWAP EDX;
{$ENDIF CPUX64}
end;

[ShaiLeTroll]

Dans le sujet mentionné précédemment, une fonction d'ailleurs n'avait pas été modernisé, faut changer pas mal de chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function LowCharCase(C: Char): Char;
asm
{$IFDEF CPUX64}
  CMP     CL,'A'
  JB      @@exit
  CMP     CL,'Z'
  JA      @@exit
  SUB     CL,'A' - 'a'
  MOV AL, CL;
{$ELSE}
  CMP     AL,'A'
  JB      @@exit
  CMP     AL,'Z'
  JA      @@exit
  SUB     AL,'A' - 'a'
{$ENDIF CPUX64}
@@exit:
end;

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
function LowCharCase(C: Char): Char;
asm
{$IFDEF CPUX64}
  MOV AL, CL;
{$ENDIF CPUX64}
  CMP     AL,'A'
  JB      @@exit
  CMP     AL,'Z'
  JA      @@exit
  SUB     AL,'A' - 'a'
 
@@exit:
end;

[tourlourou]

Bonjour René,

Toujours sur les grands entiers et les nombres premiers ?

Bon code,
Yves.

[Rekin85]

Bon, merci à tous, vos avis comptent beaucoup pour moi.

Je vais m'adresser à Yves et Schai en particulier pour faire comprendre ma question (un peu stupide il faut dire). Et oui Yves, après tous mes déboires dûs à mon âge (hum bientôt 82 balais), j'ai cessé de me consacrer aussi assidûment à la programmation. J'avais cru à l'ouverture de possibilités énormes avec l'arrivée du 64 bits… Après être passé par le 8 bits (Ah mon premier TO9 et son 6809 !...) puis les Dos Microsoft avec les interruptions système, ce fut le rayonnement avec l'arrivée du merveilleux Windows 3.11 et Delphi 3 ! Je suis parvenu ainsi en autodidacte jusqu'à Windows 10 et Delphi 7 avec l'utilisation de l'ASM en particulier : la plénitude ! Vraiment. De quoi oublier que la vieillesse subrepticement venait vous saper et vous enlever vos capacités physiques et intellectuelles sans prévenir.

Et puis il y a eu aussi les excellents moments de recherches et investigations sur les nombres entiers géants en compagnie de mon ami Gilbert Geyer; des nuits entières de clavier pour parvenir à des petits résultats honorables.

Je mesure la difficulté que j'aurais à passer au 64 bits avec les versions nouvelles de Delphi et je ne m'en sens pas assez le courage à tout repotasser à nouveau. Oui mais voilà, le cerveau tourne toujours, surtout la nuit... Et oui Yves, il y a toujours ces maudits nombres premiers qui viennent me chatouiller les neurones pour bien souvent aboutir à des désillusions en laissant quand même des espoirs de recherches. Mais j'ai l'impression d'être au bout.

Alors il m'arrive encore de faire tourner mes derniers programmes (et ils tournent bien ! ) Je suis fier des deux derniers l'un en cryptologie et l'autre qui me titille toujours sur la répartition des nombres premiers sur des très très longues distances dans l'univers des nombres entiers.

Faut-il pour aller plus loin que je m'intéresse au 64 bits ? Bah ...

Portez vous bien tous.

[Artemus24]

Salut Rekin85.

Je ne savais pas que vous vous intéressiez aux nombres premiers, enfin aux mathématiques en général.
Serait-ce pour trouver de nouveaux nombres premiers ou pour trouver un schéma sous-jacent ?
Peut on savoir ce que vous faites ?

Le 64 bits permet de simplifier quelques algorithmes mais son principale inconvénient est de remettre en question tout ce que l'on a déjà fait.

[Rekin85]

Bonjour Artemus

Au départ, il y a une quinzaine d'années, je me passionnais pour la cryptologie. A l'époque la vedette revenait au RSA. Donc il m'a fallu dans un premier temps rechercher une méthode de génération des nombres premiers et de plus en plus grands. Un ami prof de maths m'a fait connaître un algorithme de test de primalité : le fameux Miller-Rabbin ; merveilleux et fiable à plus de 99%. Alors des nombres premiers à la pelle , mais voilà : la barrière du 32 bits des processeurs x86.

Pour aller plus loin, il m'a alors fallu créer une arithmétique complète pour des nombres entiers géants. L'idée étant de ne pas s'imposer de limite de taille comme pour les Int64 de Delphi. Cela a entraîné une gestion rigoureuse de la mémoire et, pour gagner énormément en vitesse de calcul, l'utilisation généralisée de l'assembleur dans Delphi. Heureusement j'ai bénéficié de l'aide de Gilbert Geyer et nous avons ainsi développé deux bibliothèques de procédures et fonctions pour cela:

https://delphi.developpez.com/telech...entiers-geants

Du bon boulot, Gilbert a pu mener à bien son grand projet de calcul scientifique, et moi je suis parti sur tout autre chose que du RSA. Maintenant je pouvais créer des nombres premiers très géants aussi. La transposition en ASM du test de Miller-Rabbin est particulièrement véloce.

Un vieux rêve m'est alors revenu en tête : la fameuse formule Pi(n) ; ou comment calculer le nième nombre premier. Pi(1)=1 , Pi(2)=2 , Pi(3)=3 , Pi(4)=5 , Pi(5)=7 , Pi(6)=11 , .... , Pi(n) = ? . Personne ne l'a encore trouvée. Je me suis donc mis en tête de vouloir représenter ces nombres premiers graphiquement parmi les nombres entiers et ainsi me permettre de voir leur répartition (simplifiée) dans l'ensemble N pour y découvrir quoi (?) : des patterns ? Des redondances ? des fluctuations remarquables ? ou alors rien de significatif ?

J'ai donc développé un petit programme qui me fait un mapping des nombres premiers par myriade d'entiers. Une myriade en arithmétique c'est 10 000. Et pour gagner du temps de calcul et de la place représentative, je m'appuie sur le théorème suivant : "Tout nombre premiers dans l'ensemble des entiers précède ou suit un nombre multiple de 6" , ou pour être plus précis : "Tout nombre premier quel qu'il soit est de la forme 6k + ou - 1" avec la grande précaution que la réciproque n'est surtout pas vraie.

Voici à titre d'exemple le mapping sur 35 colonnes de la première myriade (de 1 à 9 999) qui s'affiche à l'écran en une toute petite fraction de seconde :



Les multiples de 6 sont indiqués par les petits tirets bleus du premier au dernier de la myriade ( de 6 à 9 996 ) les nombres premiers quand ils existent sont représentés par un petit carré rouge devant (6k-1) ou un petit carré vert derrière (6k+1). Il y en a 1 227 dont 204 paires de jumeaux (rouge et vert à la fois).
Bien sûr un petit curseur pilotable permet d'aller cibler ceux que l'on veut et obtenir leurs valeurs.

Voici maintenant le mapping de la 120 x 10^21 -ème myriade d'entiers ( de 119 999 999 999 999 999 999 000 à 120 000 000 000 000 000 000 000 ) qui s'affiche en 1 seconde et demie :



Elle présente 189 premiers dont 4 paires de jumeaux.

J'ai bien sûr essayé des myriades astronomiques comme la 1 x 10^100000 -ème et plus qui peuvent mettre plusieurs minutes pour s'afficher. Pour l'instant, je peux affirmer que le nombres de premiers devient asymptotique de 0. C'est à dire rien de sérieux. Je n'ai pas encore trouvé la myriade qui n'en contient pas.

Décevants les nombres premiers ils ne semblent suivre aucune logique. Et pourtant j'ai la conviction qu'il y en a une ....

[Artemus24]

Merci pour tes explications.
Je possède quelques livres sur le sujet et je me suis intéressé aux nombres de Mersenne.
Rien de comparable avec ce que vous faites. Je reviendrais un de ces jours sur ce sujet qui m'intéresse.

Pourquoi Delphi et pas de l'assembleur pur ?

[Rekin85]

Bonsoir.

Pourquoi Delphi ? Parce qu'après avoir fait du basic ( print"Bonjour" ), je suis passé au pascal et puis à Delphi qui permet très facilement de bâtir des programmes-interfaces très facilement et relativement vite. L'assembleur pour moi c'est quand je n'ai pas de solution dans Delphi ou alors qu'il me faut une rapidité d'exécution plus grande.

Mais maintenant je suis plus âgé et n'ose pas me lancer dans du plus sophistiqué.

[Rekin85]

Bonsoir à toutes et tous.

Je m'adresse en particulier à Yves et Artemus24 pour leur petit intérêt sur les travaux sur les nombres premiers. J'ai peaufiné mon petit programme d'affichage de ces nombres particuliers par myriades. Certes il m'affichait un mapping de répartition par rapport aux multiples de 6 de la myriade choisie, mais dés que je passais à une autre ou que je fermais l'ordinateur, Pfit ! plus rien sauf peut-être si je les avais relevés au passage, tous ces beaux nombres s'envolaient allégrement.
J'ai donc réouvert mon bon vieux D7 pour développer une annexe qui permet la synthèse des résultats, les afficher et les imprimer au besoin (hum de quoi se donner des tonnes de renseignements pour exploitation et/ou réflexions.

Voici les résultats pour la 10^100 (1 suivi de 100 zéros) ième myriade :

img20260405_19582513.pdf

Voilà, après cela, je crois que je vais replier mes gaules encore une fois (?) et m'endormir gentiment sur mes faux lauriers...

Adieux les amis. (Ou peut-être au revoir...)

[der§en]

Petite question de béotien, pourquoi des multiples de 6, je n’ai pas bien compris le rapport avec les nombres premiers ?

[Rekin85]

Bonjour Dersen.

Alors un peu de mathématique :

Soit K un nombre quelconque plus grand que cinq et divisible par 6. Il est donc à la fois divisible par 2 et par 3.

Donc K=6k, c'est un nombre pair.

Les nombres K-1 = 6k-1 et K+1 = 6k+1 sont des nombres impairs susceptibles d'être des nombres premiers mais pas forcément (il faut le prouver).

Les nombres K-2 = 6k-2 et K+2 = 6k+2 sont respectivement égaux à 2(3k-1) et 2(3k+1) donc forcément pairs.

Les nombres K-3 = 6k-3 et K+3 = 6k+3 sont respectivement égaux à 3(2k-1) et 3(2k+1) donc tous deux divisibles par 3.

On a ainsi démontré que : A partir de 5, tous les nombres premiers sont obligatoirement de la forme 6k+-1. Théorème important mais attention la réciproque n'est pas forcément vraie.

Conclusion : si on cherche des nombres premiers dans l'ensemble N, on ne peut obligatoirement les trouver que devant ou derrière un nombre multiple de 6 et si quelques fois le 6k-1 et le 6k+1 sont tous deux premiers on a là deux premiers dits jumeaux.

Cela permet de resserrer les calculs autour de ces multiples de 6. J'ai dit qu'il fallait prouver la primalité ? Un petit exemple tout simple : prenons les nombres entiers à partir de 6

6-1=5 (premier) 6+1=7 (premier)
12-1=11 (premier) 12+1=13 (premier)
18-1=17 (premier) 18+1=19 (premier)
24-1=23 (premier) 24+1= 25 (non premier car divisible par 5)
30-1=29 (premier) 30+1=31 (premier)
36-1=35 (non premier) 36+1=37(premier)
etc... etc...

Voilà donc l'objet de mon petit programme : déterminer rapidement les nombres premiers d'une myriade de rang n. en ne testant que les précédents et les suivants des multiples de 6 par le fameux test de Miller-Rabin fiable à plus de 90%...

Ai-je été clair ?

Pour exemple la première myriade (de 0 à 9 999) en contient 1227, la 2ème myriade (de 10 000 à 19 999) en contient 878, la 3ème (de 20 000 à 29 999) en contient 720, etc...

Avec mon petit programme je n'ai pas de limite de taille des nombres, il n'y a que les temps de calculs qui s'allongent à partir de nombres à plus de 100 chiffres.

[der§en]

Mille merci, bon, j’avoue que j’ai bien relue 2 fois pour en comprendre toute la réflexion mais la démonstration est étonnante et passionnante !

[Artemus24]

Salut à tous.

Pour être un peu plus explicite, il s'agit de trouver dans l'expression 6*k + n, tous les n qui ne divisent pas 6, donc avec n=1,5.
Mais en suivant le même raisonnement, tu as aussi 30, 210, 2310, ...
Ce sont les factoriels des nombres premiers :
--> 6 = 2*3
--> 30 = 2*3*5
--> 210 = 2*3*5*7
--> 2310 = 2*3*5*7*11
Il faut lire factoriel des nombres premiers, qui se note 3!, 5!, 7!, 11!.
L'expression devient alors "x! * k + n" avec n qui n'a aucun diviseur en commun avec x!.

Par exemple pour x=5, cela donne 5!=30, et les n sont 1, 7, 11, 13, 17, 19, 23.
C'est une façon d'appliquer le Crible d'Ératosthène pour réduire la recherche des nombres premiers.

Au lieu de rester sur l'expression "x! * k + n" quand tu as fixé une fois pour toute le x, tu peux appliquer cette méthode pour chaque palier.
Par palier, j'entends le passage d'un x au nombre premier suivant.
En fait, tu restes toujours avec k=1, mais tu fais varier les x.
Cela permet d'éviter de perdre son temps avec des nombres qui sont susceptibles de ne pas être premier selon cette méthode.

L'intérêt de la méthode de Rekin85 est sa simplicité, mais elle n'est pas optimale.

Pour affiner la recherche de la primalité, il faudrait trouver une relation entre ce x! et ce n où le PGCD (plus grand commun diviseur) n'est pas suffisant.

[Rekin85]

Merci Artemus24. La méthode du crible d'Eratosthène est infaillible, mais elle nécessite de calculer la primorielle (factorielle des premiers) de tous les premiers précédents qu'il faut donc calculer et découvrir et connaître au fur et à mesure (hum bonjour l'algorithmique ...) . Et puis il y a les calculs, avec des nombres de moins de 32 ou 64 bits bon d'accord. Mais après ? quand on veut avoir un bon nombre premier d'au moins 100 chiffres ? de 1000 chiffres ? de ...

Bien à plus les amis.

[Artemus24]

Ce n'est pas exactement le crible d'Ératosthène, mais il s'en inspire grandement.
Comme tu le sais, plus tu vas dans les grands nombres et plus les nombres premiers se raréfient.
Il faut trouver le moyen de rejeter ceux qui ne sont pas susceptibles d'être de bons candidats.
Après, sur ce candidat sélectionné, tu peux appliquer le test de la primalité.

L'approche sur le modulo 2 (=1x2).
--> 2 * k + n < 6.
Ce qui donne :
--> k=0 ==> {1, 3}
--> k=1 ==> {3, 5}

Comme tu peux le voir, chaque n candidat peut s'écrire :
--> n₀ = 2 * k + 1
--> n₁ = 2 * k + 3

L'approche sur le modulo 6 (=1x2x3).
--> 6 * k + n < 30.
Ce qui donne :
--> k=0 ==> {1, 5}
--> k=1 ==> {7, 11}
--> k=2 ==> {13, 17}
--> k=3 ==> {19, 23}
--> k=5 ==> {25, 29}

Chaque n candidat s'écrit :
--> n₀ = 6 * k + 1
--> n₁ = 6 * k + 5

L'approche sur le modulo 30 (=1x2x3x5).
--> 30 * k + n < 210
Ce qui donne :
--> k=0 ==> { 1, 7, 11, 13, 17, 19, 23 ,29}
--> k=1 ==> { 31, 37, 41, 43, 47, 49, 53, 59}
--> k=2 ==> { 61, 67, 71, 73, 77, 79, 83, 89}
--> k=3 ==> { 91, 97, 101, 103, 107, 109, 113, 119}
--> k=4 ==> {121, 127, 131, 133, 137, 139, 143, 149}
--> k=5 ==> {151, 157, 161, 163, 167, 169, 173, 179}
--> k=6 ==> {181, 187, 191, 193, 197, 199, 203, 209}

soit :
--> n₀ = 30 * k + 1
--> n₁ = 30 * k + 7
--> n₂ = 30 * k + 11
--> n₃ = 30 * k + 13
--> n₄ = 30 * k + 17
--> n₅ = 30 * k + 19
--> n₆ = 30 * k + 23
--> n₇ = 30 * k + 29

Je m'arrête là car l'exemple est suffisamment parlant.

Chaque n est construit sur la base du modulo précédent, avec rejet de ceux qui ne passent pas le test de la primalité.
En fait, cela se calcule sur le PGCD (x! , n) = 1
Tu as ici une méthode récursive qui permet de trouver tous les bons candidats.
Tu élimines une grande quantité de nombres qui ne sont pas susceptibles d'être de bons candidats.
Cela permet d'accélérer les calculs et d'obtenir plus rapidement les résultats attendus.

[Rekin85]

Merci beaucoup Artemus24 pour tes précieuses explications... Je t'avoue que je m'étais dit à plusieurs reprises que puisque je suivais ce raisonnement sur 6k+-1, qu'une fois arrivé à 30 (2x3x5) je ne pourrais pas, peut-être raccourcir les temps de calculs ???? Certes mais comme le test de primalité élimine les mauvais candidats très vite, j'étais déjà bien content.

Bon ce qu'il faut maintenant, c'est cogiter un algorithme adéquat. Si j'ai force et courage (et surtout du temps devant moi)... Pourquoi pas ?

[Artemus24]

J'ai indiqué en vert les nombres n_i qui ne sont pas des nombres premiers.
Cela ne veut pas dire qu'ils seront rejetés car ils doivent d'abord passer le test du PGCD(x!, n_i) = 1

Avec cette méthode, tu t'aperçois que tu as un trou énorme entre n₁ et n₂ qui ne fait que grandir quand ton x! augmente. Il vaut mieux rechercher les candidats en partant du n_i en faisant varier l'indice i du plus grand que tu vas trouver jusqu'à i=2. C'est dans cet intervalle que tes candidats seront le plus susceptibles d'être des nombres premiers. Le but de ce crible est de gagner du temps.

Je connais le test de Fermat ( a^n-1 congru 1 (mod n) ) mais il donne de faux nombres premiers que l'on nomme dans la littérature mathématique les nombres de Carmichael. Il y a d'autres tests comme celui de Miller-Rabin, mais celui-ci est plus lent que le test de Fermat.

Il doit exister d'autres approches pour éliminer les mauvais candidats, et je pense que c'est là dessus que tu devrais te concentrer, plus que sur le test de primalité.