Discussion :

[nitteo]

Bonjour à tous,

J'ai un petit souci avec un algo.
j'ai une variable dans mon registre eax (que je connais)
puis une fonction imul avec la variable que je cherche
le tout donne un résultat de cette forme XXXXXXX 00000001

comment je peux exprimer la variable qui se multiplie à eax
en fonction du reste ?
merci d'avance

[nitteo]

voici un algo qui teste toutes les valeurs:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
xor ebx,ebx ; vide ebx
;mov edx,593D7Fh
temperature:
mov eax,593D7Fh ;met une variable dans eax
imul eax,ebx ; multiplie par ebx
inc ebx ;incremente ebx
cmp eax,00000001h ;compare jusqu'à trouver 1 dans eax
jnz temperature ;test une autre valeur de ebx
dec ebx ;decremente avant de l'afficher
call DumpRegs ;affiches les registres

le problème c'est que c'est beaucoup trop long comme ça
5 secondes sur mon athlon

[wwwwwwo]

comment je peux exprimer la variable qui se multiplie à eax
en fonction du reste ?

J'ai bô relire et regarder le bout de code je n'arrive pas à saisir (j'ai l'unique qui lâche de temps en temps )... multiplication/reste ?

Pourrais-tu nous donner un peu plus de contexte et de précisions (IMUL ou IDIV j'arrive à douter entre : Titre - reste - et contenu du post...).

Au début, à cause du titre j'ai compris :
X/MaVarconnue = quotient | reste -> déduire X à partir de reste ?

merci

[nitteo]

en admettant que eax=5848447 (d)
ceci:

4294967296.x + 1 = y
_______________
5848447

est equivalent à cela:

5848447.y - 1 = x
____________
4294967296

ce que je veux c'est avoir x et y entiers pour n'importe qu'elle valeur donnée à eax
en gros, résoudre l'équation pour que x ET y soit entiers, merci.

[wwwwwwo]

La valeur (4294967296) 1 0000 0000 hex est une constante donc ?

Si oui, elle est donc de format QWORD et peux donc être aussi représentée comme une valeur DWORD 0000 0001 qui serait le MSDW de ton QWORD et .x serait la partie décimale de ton QWORD sur un LSDW (ouf ) ? MSDW (Partie e) LSDW(partie d)

Donc, de la virgule fixe en QWORD ?

Est-ce bien cela (ça clarifierait le problème de résolution et permettrait d'opter pour la meilleure stratégie) ?

Cependant, 5848447 dans eax (précédée de d) signifie que dans la première expression eax est utilisé en tant que partie décimale du diviseur (je ne vois pas de .)?

[nitteo]

non le point est le signe de multiplication
4294967296 est bien constante
eax = 5848447

on m'a conseiller d'utiliser les équations diophantiennes avec l'algorithme d'Euclid ou la méthode de Bézout
mais je ne comprend pas tout

il faut résoudre dans Z (entiers)
4294967296 x - 5848447 y = 1 , {x,y},Integers

[wwwwwwo]

non le point est le signe de multiplication

harghhh and grummfff !

Bon, plus je regarde le bout de code moins je comprends (pas d'itération, mais j'imagine...) de plus dès qu' ebx <>0 la condition suivante est vérifiée...

Pourrais-tu nous exposer le problème dans son ensemble, histoire de pas tourner en rond et de chercher une solution efficace et pragmatique.

[nitteo]

ce que je veux c'est resoudre cette equation ci-dessus

voila mon prog:

Code :

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

1
2
3
4
5
6
 
mov eax,593D7Fh ;ce nombre peut changer à tout moment
xor edx,edx ;vide edx
imul 0BD80827Fh ;c'est ce nombre que je veux obtenir
;pour le connaitre j'ai testé plein de valeurs
;dans une boucle

------------------------------------------------
dans les registres, j'ai:
eax = 00000001h
edx = FFE8D1B4h

car 593D7F * BD80827F = FFE8D1B4 00000001
d'ou eax * edx = partie haute partie basse

dans mon equation je connais eax et partie basse
et je veux edx et partie haute

---
pouvez vous transferer ce topic dans algorithmie ?
merci

[wwwwwwo]

car 593D7F * BD80827F = FFE8D1B4 00000001

(420F33 00000001 mais peu importe...)

je pense qu'en débrouillant un peu tout ça tout le monde commence à saisir les données de ton problème.

[nitteo]

c'est bon j'ai trouvé comment brutforcer l'algorithme sur mon athlon en moins d'une seconde

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
19
20
21
22
23
 
xor ebx,ebx
boucle: ;brutforce pour trouver la fin correcte
mov eax,0F67Dh
imul eax,ebx
and eax,0FFFFh
inc ebx
cmp eax,0001h
jnz boucle
dec ebx
call DumpRegs
 
;xor ebx,ebx ; vide ebx
;mov edx,593D7Fh
;mov ebx,827Fh
temperature: ;brutforce pour trouver le debut par rapport a la fin correcte
mov eax,99F67Dh ;met une variable dans eax
imul eax,ebx ; multiplie par ebx
add ebx,10000h ;incremente ebx
cmp eax,00000001h ;compare jusqu'à trouver 1 dans eax
jnz temperature ;test une autre valeur de ebx
sub ebx,10000h ;decremente avant de l'afficher
call DumpRegs ;affiches les registres

en gros pour ceux que ça interesse je suis passé d'un brutforce de FFFFFFFFh valeurs à 2 brutforces de FFFFh valeurs
pourquoi je n'y avais pas penser ?

[wwwwwwo]

en plus une solution perso c'est toujours bien plus satisfaisant qu'une solution étrangère

Bravo

[wwwwwwo]

PS : (Syntaxe RosAsm)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
     mov ebx 0-1 ; Pour éviter un dec
 
L0: inc ebx 
     mov eax 0_F67D
     imul eax ebx
     and eax 0_FFFF 
; cmp eax 0001h puisqu'il n'est pas question de cherhcer une égalité mais <> 0 ...
 
jnz L0< ; saut vers un label local 
 
     call DumpRegs

[nitteo]

bien vu !

[wwwwwwo]

je n'ai pas mis les deux branches mais tu auras compris...

Ceci dit, tu pourrais aussi éviter la multiplication par N+1 et la remplacer par un addition ou même un :

lea eax D$eax+0_xxxx (mais pas de MAJ des flags...)

ce qui permet aussi de faire sauter le and 0_FFFF



En fait, comme d'hab. : Ne pas le faire va plus vite.

ceci dit : dès que ebx > 0 eax <> 0 ...

Donc... je ne comprends pas bien le sens de tout ça... mais ça devrait aller beaucoup plus vite avec la suppression des IMUL et le saut direct



Vu que le CMP ne sert pas à grand-chose à cause du jnz ne serait-il pas plus logique, dans le cas d'un CMP, d'avoir une validation (conforme à tes rem) ->>> je ?