valeurs - remplir un tableau avec des nombres aléatoires distincts c#




Nombre aléatoire entre 2 nombres doubles (7)

Est-il possible de générer un nombre aléatoire entre 2 doubles?

Exemple:

public double GetRandomeNumber(double minimum, double maximum)
{
    return Random.NextDouble(minimum, maximum) 
}

Ensuite, je l'appelle avec ce qui suit:

double result = GetRandomNumber(1.23, 5.34);

Toute réflexion sera apprécié.


A propos de la génération du même nombre aléatoire si vous l'appelez dans une boucle, une solution astucieuse consiste à déclarer le nouvel objet Random () en dehors de la boucle en tant que variable globale.

Notez que vous devez déclarer votre instance de la classe Random en dehors de la fonction GetRandomInt si vous allez l'exécuter en boucle.

"Pourquoi est-ce?" Demandez-vous.

Eh bien, la classe Random génère réellement des nombres pseudo-aléatoires, avec le "seed" pour le randomizer étant l'heure du système. Si votre boucle est suffisamment rapide, l'heure de l'horloge du système n'apparaîtra pas différemment du randomizer et chaque nouvelle instance de la classe Random commencera avec la même graine et vous donnera le même nombre pseudo-aléatoire.

Source est ici: http://www.whypad.com/posts/csharp-get-a-random-number-between-x-and-y/412/


Attention: si vous générez le random dans une boucle comme par exemple for(int i = 0; i < 10; i++) , ne mettez pas la new Random() déclaration new Random() dans la boucle.

De MSDN :

La génération de nombre aléatoire commence à partir d'une valeur de départ. Si la même graine est utilisée plusieurs fois, la même série de nombres est générée. Une façon de produire des séquences différentes est de rendre la valeur de départ dépendante du temps, produisant ainsi une série différente avec 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 de départ ...

Donc, basé sur ce fait, faire quelque chose comme:

var random = new Random();

for(int d = 0; d < 7; d++)
{
    // Actual BOE
    boes.Add(new LogBOEViewModel()
    {
        LogDate = criteriaDate,
        BOEActual = GetRandomDouble(random, 100, 1000),
        BOEForecast = GetRandomDouble(random, 100, 1000)
    });
}

double GetRandomDouble(Random random, double min, double max)
{
     return min + (random.NextDouble() * (max - min));
}

De cette façon, vous avez la garantie que vous aurez différentes valeurs doubles.


L'approche la plus simple générerait simplement un nombre aléatoire entre 0 et la différence des deux nombres. Puis ajoutez le plus petit des deux nombres au résultat.


Oui.

Random.NextDouble renvoie un double entre 0 et 1. Vous multipliez ensuite cela par la plage dans laquelle vous devez entrer (différence entre le maximum et le minimum), puis ajoutez-le à la base (minimum).

public double GetRandomNumber(double minimum, double maximum)
{ 
    Random random = new Random();
    return random.NextDouble() * (maximum - minimum) + minimum;
}

Le code réel devrait être un membre statique. Cela permettra d'économiser le coût de création du générateur de nombres aléatoires, et vous permettra d'appeler GetRandomNumber très fréquemment. Puisque nous initialisons un nouveau RNG avec chaque appel, si vous appelez assez vite pour que l'heure du système ne change pas entre les appels, le RNG sera placé avec exactement le même horodatage, et générera le même flux de nombres aléatoires.


Vous pourriez faire ceci:

public class RandomNumbers : Random
{
    public RandomNumbers(int seed) : base(seed) { }

    public double NextDouble(double minimum, double maximum)
    {
        return base.NextDouble() * (maximum - minimum) + minimum;
    }
}

Vous pouvez utiliser du code comme ceci:

public double getRandomNumber(double minimum, double maximum) {
    return minimum + randomizer.nextDouble() * (maximum - minimum);
}

Random random = new Random();

double NextDouble(double minimum, double maximum)
{  

    return random.NextDouble()*random.Next(minimum,maximum);

}




random