Discussion :

[oliverell62]

bonjour,

j ai un petit probleme que je ne pense pouvoir resoudre seul,
j ai créé un simulateur de combat pour un jeu en ligne, les resultats etaient correct pour peu de flotte ...

mais des que je passais a plus de 2/3000 unites, ca buggé

mon algo utilise des valeurs aleatoire entre 0 et 1

j utilisais donc randomize puis rnd()

comme ca ne tournais pas rond au niveau des résultats

j ai utilisé systeme.random puis r.NextDouble()

sans succés

puis j ai eu une petite idée, j ai endormi le système avec sleep(5) avant chaque génération aleatoire et la miracle, les calculs sont exacts

mais alors le temps d exécution fait peur


comment puis je m en sortir , générer de vrais aléatoires sans devoir geler le système ?????

ou alors, je dois peut etre faire une manip que je ne connais pas


merci d avance

[Sankasssss]

C'est un problème du framework .net
Les nombre sont généré pseudo aléatoirement avec l'horloge du pc, donc si tu boucle très vite, l'horloge ne changeant pas, le résultat de sortie est le même...

voir : http://msdn.microsoft.com/fr-be/libr...em.random.aspx

La génération de nombres aléatoires commence à partir d'une valeur initiale.Lorsque la même valeur initiale est utilisée à plusieurs reprises, la même série de nombres est générée.Pour générer des séquences différentes, il est possible de rendre la valeur initiale dépendante du temps. Dans ce cas, une série différente est obtenue pour chaque nouvelle instance de Random.Par défaut, le constructeur sans paramètre de la classe Random utilise l'horloge système pour générer sa valeur initiale, pendant que son constructeur paramétré peut prendre une valeur Int32 selon le nombre de graduations dans l'heure actuelle.Toutefois, l'horloge disposant de la résolution finie, la création successive d'objets Random différents à l'aide du constructeur sans paramètre crée des générateurs de nombres aléatoires qui produisent des séquences identiques de nombres aléatoires.L'exemple suivant montre comment deux objets Random instanciés successivement génèrent une série identique de nombres aléatoires.

Personnellement, pour contourner ce problème, j'ai créé un tableau d'integer d'une 20ene d'éléments, à chaque fois que je crée un random je lui passe un élément différent (en incrémentant un index) du tableau que je fait diviser l'horloge. de cette manière je suis sur d'avoir toujours un nombre différent.

Pour ma part, je me suis arraché les cheveux car quand je mettais l'application sans point d'arrêt ca ne fonctionnais pas, les valeurs était toujours les mêmes, et des que je voulais voir pourquoi, en mettant un point d'arrêt ca fonctionnait, logique puisque j'arrêtais l'application et qu'au tour suivant quand je faisais un autre nombre aléatoire, l'horloge avait changé ce qui n'était pas le cas sans le point d'arrêt

[oliverell62]

oula merci ,

je comprends mieux maintenant mon pb,

pour le tableau d integer, pk pas, je pourrais generer ca au démarrage de l appli;

je vais regarder comment passer un interger en paramètre de manière efficace

juste une derniere question, ton tableau de 20 integer suffise pour une boucle de combien d élément ( de tete je pense que je dois a chaque simulation je peux simuler des milliers d aléatoire ........ ) le tableau devrait comporter combien d élément pour etre crédible ?


ps merci pour cette reponse super rapide ...



edit : en y reflechissant et en comparant mes resultats, r.nextdouble est plus precis que rnd() si jamais ca interesse quelqu'un

[Sankasssss]

juste une derniere question, ton tableau de 20 integer suffise pour une boucle de combien d élément ( de tete je pense que je dois a chaque simulation je peux simuler des milliers d aléatoire ........ ) le tableau devrait comporter combien d élément pour etre crédible ?

Personnellement c'est pour attribuer des dossier aléatoirement a des personnes, il y a en générale plus ou moins 300 dossiers à répartir.
Mais ca ne changerais rien pour des milliers d'éléments, le seul truc à penser c'est de mettre plus d'éléments que le nombre qui peut être traité dans un espace de temps, de cette manière, quand tu divises le temps par un de tes éléments tu as toujours un nombre différent, c'est aussi pour ca que j'ai continué à utilisé le temps comme base, car si on se contentait du tableau de 20 éléments, nous n'aurions plus rien d'aléatoire, se serait toujours la même séquence qui sortirait

Donc si on voudrait savoir combien d'élément il faudrait réellement on pourrait essayé de savoir combien d'opération sont possible par Ticks (valeur que j'utilise pour la division), sachant que un Ticks représente 100 nanosecondes. Combien de ligne de code le(s) processeur(s) peut-il faire en 100 nanosecondes ?
J'ai pas cherché à calculé et j'ai essayé avec 20 éléments ce qui a suffit...

edit : en y reflechissant et en comparant mes resultats, r.nextdouble est plus precis que rnd() si jamais ca interesse quelqu'un

C'est bon à savoir

[oliverell62]

oki, merci ...

je vais donc proceder par tatonnement

ou mieux quelque chose du genre :

Code :

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

1
2
3
4
5
private funtion recherche_integer ( byval i as integer)
 randomize()
i = i + Int(Rnd() *10
return i
end function

ce qui a l avantage
=> de ne pas requerir a un tableau fini (si on garde i comme reference pour tout le prog )
=> ne pas etre sensible aux pseudos aleatoires ( meme si rnd() envois des faux aléatoires on se sert au final de l incrémentation => on se servira de l integer incrémenté pour générer le "vrai" aleatoire .... )


bref c qu une idée, je vais y réfléchir, j ai maintenant des pistes de travail


merci


ps : pas eu le courage de faire la division :p
pps : resolu