Discussion :

[chidi]

Je veux écrire une fonction qui me permet de générer des entier au hasard

[Neitsa]

bonjour,

Tout dépend du type de "hasard" que tu souhaites. Si c'est un hasard poussé, il va falloir y passé des nuits blanches car c'est très difficile et nécessite des connaissances mathématique poussées.

Si tu veux un hasard, disons trivial, en asm win32 tu peux appeler GetTickCount (un tick 18.2 fois par seconde) ou QueryPerformanceCounter, qui peut te retourner des nombres en plus grosse quantité. A toi d'implémenter qque chose derrière pour avoir un "pseudo random generator".

Pour l'asm 16 bits je laisse la main au personnes plus compétentes.

Neitsa.

[ShootDX]

Numerical Recipes

[executter]

salut,

à ma connaissance le meilleur algo de générations de nombres pseudo-aléatoires est le MT19937 écrit par 2 jap.

en voici un petit portage asm :

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
; An ASM version of MT19937 : a pseudo-random number generating algorithm by Makoto Matsumoto et Takuji Nishimura
; http://www.math.keio.ac.jp/~matumoto/emt.html
 
; Retranscribed by executter starting from the C version of the 2002/1/26
 
Randomize PROTO :DWORD
Random PROTO :DWORD
 
.const
  N equ 624
  M equ 397
  MATRIX_A  equ 9908B0DFh
  UPPER_MASK equ 80000000h
  LOWER_MASK equ 7FFFFFFFh
 
.data
  mti dd (N + 1)
 
.data?
  mt dd N dup (?)
 
.code
  Randomize PROC Seed_Randomize:DWORD
    mov eax, Seed_Randomize
    mov dword ptr [mt], eax
    mov ecx, 1
    .WHILE ecx < N
      mov edx, eax
      shr eax, 30
      xor eax, edx
      mov edx, 1812433253
      mul edx
      add eax, ecx
      mov dword ptr [mt + ecx * 4], eax
      inc ecx
    .ENDW
    mov mti, ecx
    ret
  Randomize ENDP
 
  Random PROC Limite_Random:DWORD
    .IF mti >= N
      .IF mti == (N + 1)
        invoke Randomize, 5489
      .ENDIF
      xor ecx, ecx
      .WHILE ecx < (N - M)
        mov eax, dword ptr [mt + ecx * 4]
        and eax, UPPER_MASK
        mov edx, dword ptr [mt + ecx * 4 + 4]
        and edx, LOWER_MASK
        or eax, edx
        shr eax, 1
        jnc @f
          xor eax, MATRIX_A
        @@:
        xor eax, dword ptr [mt + ecx * 4 + M * 4]
        mov dword ptr [mt + ecx * 4], eax
        inc ecx
      .ENDW
      .WHILE ecx < (N - 1)
        mov eax, dword ptr [mt + ecx * 4]
        and eax, UPPER_MASK
        mov edx, dword ptr [mt + ecx * 4 + 4]
        and edx, LOWER_MASK
        or eax, edx
        shr eax, 1
        jnc @f
          xor eax, MATRIX_A
        @@:
        xor eax, dword ptr [mt + ecx * 4 + (M - N) * 4]
        mov dword ptr [mt + ecx * 4], eax
        inc ecx
      .ENDW
      mov eax, dword ptr [mt + (N - 1) * 4]
      and eax, UPPER_MASK
      mov edx, dword ptr [mt]
      and edx, LOWER_MASK
      or eax, edx
      shr eax, 1
      jnc @f
        xor eax, MATRIX_A
      @@:
      xor eax, dword ptr [mt + (M - 1) * 4]
      mov dword ptr [mt + (N - 1) * 4], eax
      mov mti, 0
    .ENDIF
    mov ecx, mti
    shl ecx, 2
    mov eax, dword ptr [mt + ecx]
    inc mti
    mov edx, eax
    shr edx, 11
    xor eax, edx
    mov edx, eax
    shl edx, 7
    and edx, 9d2c5680h
    xor eax, edx
    mov edx, eax
    shl edx, 15
    and edx, 0efc60000h
    xor eax, edx
    mov edx, eax
    shr edx, 18
    xor eax, edx
    xor edx, edx
    div Limite_Random
    xchg eax, edx
    ret
  Random ENDP

c'est du code pour masm32.

[Selenite]

Sur x86, rdtsc est une instruction qui stock dans edx/eax un nombre de 64 bits représentant le nombre de cycle horloge fait depuis le démarrage.

En appelant cette instruction une fois, tu obtient 32 bits de eax aléatoires de bonne qualité.

[Pierre Maurette]

Bonjour,

http://www.agner.org/random/

Pour RDTSC, le registre EAX "tourne" en 4,3 secondes sur une machine à 1GHz. Si c'est "un peu juste", en cas de lectures successives particulièrement, AX sur 16 bits tourne fatalement 65536 fois plus vite. Il n'en reste pas moins qu'un algo comme

Code :

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

1
2
3
4
5
6
<boucle>
  lire RDTSC
  mettre dans TAB_HASARD
  si fin TAB_HASARD aller à <suite>
  aller à <boucle>
<suite>

ne vous donnera pas un tableau de valeurs au hasard !!!

Disons que RDTSC peut fournir une bonne "semence" ou "graine" (seed).

Pierre