Develop Reference

does rnd.Next(10); include 0? or negatives

This is my code just wondering if it includes 0 as an output of the random numbers
Random rnd = new Random();
int num_2 = rnd.Next(10);
Console.WriteLine(num_2);
i tried to search it up on google but found nothin :)

Just hold down CTRL and click the left mouse button and you get:
//
// Summary:
// Returns a non-negative random integer that is less than the specified maximum.
//
// Parameters:
// maxValue:
// The exclusive upper bound of the random number to be generated. maxValue must
// be greater than or equal to 0.
//
// Returns:
// A 32-bit signed integer that is greater than or equal to 0, and less than maxValue;
// that is, the range of return values ordinarily includes 0 but not maxValue. However,
// if maxValue equals 0, maxValue is returned.
//
// Exceptions:
// T:System.ArgumentOutOfRangeException:
// maxValue is less than 0.
public virtual int Next(int maxValue);
The method will return one of the following - 0,1,2,3,4,5,6,7,8,9 (i.e. 0 can be returned but 10 cannot).

Random number issue with Next method (.NET Framework)

I need to generate a lot of random numbers which must be anywhere between 1 and int.MaxValue. The arguments passed to the Next method of the Random class are not always the same. In one senario the arguments might be as follows:
Next(1, int.MaxValue);
In another they might as well be:
Next(1, 2);
The issue here is that whenever you pass values like 1 and 2 or 99 and 100, the lower number is always the "random" number returned by the method. The reason for this is because the method subtracts 1 from the maximum value (unless min and max are the same) and then gives you the random number. How would I go about generating a range of random numbers within a range of numbers, as stated above, without getting this predictable outcome?

You would need to pass the inclusive upper bound + 1, ie:
var result = rand.Next(1, 2+1); // Returns 1 or 2
var result2 = rand.Next(99, 101); // Returns 99 or 100
Note that this won't work for int.MaxValue, of course. There is no way to have Random directly return int.MaxValue. To get a [0,int.MaxValue] result, you would need to do:
var result = rand.Next(-1, int.MaxValue) + 1;

The upper bound is exclusive, not inclusive. Given that, the range [1,2) only contains one number, 1, not two.

From the documentation, the first parameter to Next(int, int) is "The inclusive lower bound", while the second is "The exclusive upper bound".
If you want to generate a random number that might be 1 or 2, you should use the following call:
rand.Next(1, 3)

Try this
using System;
namespace ConsoleApplication3
{
class Program
{
static readonly Random r = new Random();
static void Main(string[] args)
{
for (int i = 2; i <= 100; i++)
{
Console.WriteLine(GetRandom(i));
}
}
private static int GetRandom(int i)
{
return 1 + (r.Next(int.MaxValue)%i);
}
}
}
Cheers.

You can get int.MaxValue by adding 1 after getting random int:
var result = rand.Next(1, int.MaxValue) + 1;

How about a method that takes the lower and upper limits and gives you what you're looking for?
Example:
public int GetRandom(int lower, int upper)
{
return upper == int.MaxValue ? rand.Next(lower - 1, upper) + 1 : rand.Next(lower, upper + 1);
}
If the upper limit is int.MaxValue, it shifts the range down by 1 and then adds it back after it gives the random number. Otherwise, it adds 1 to the upper limit and then gives you the random number.
Then when you use it, you'll just do something like:
var randomOne = GetRandom(1, 2);
var randomTwo = GetRandom(99,int.MaxValue);

Generate random uint

I need to generate random numbers with range for byte, ushort, sbyte, short, int, and uint. I am able to generate for all those types using the Random method in C# (e.g. values.Add((int)(random.Next(int.MinValue + 3, int.MaxValue - 2)));) except for uint since Random.Next accepts up to int values only.
Is there an easy way to generate random uint?

The simplest approach would probably be to use two calls: one for 30 bits and one for the final two. An earlier version of this answer assumed that Random.Next() had an inclusive upper bound of int.MaxValue, but it turns out it's exclusive - so we can only get 30 uniform bits.
uint thirtyBits = (uint) random.Next(1 << 30);
uint twoBits = (uint) random.Next(1 << 2);
uint fullRange = (thirtyBits << 2) | twoBits;
(You could take it in two 16-bit values of course, as an alternative... or various options in-between.)
Alternatively, you could use NextBytes to fill a 4-byte array, then use BitConverter.ToUInt32.

José's Daylight Dices
Or is there an easy way to generate a true random uint?
I admit, it's not the OQ. It will become clear that there are faster ways to generate random uints which are not true ones. Nevertheless I assume that nobody is too interested in generating those, except when a non-flat distribution is needed for some reason. Let's start with some research to get it easy and fast in C#. Easy and fast often behave like synonyms when I write code.
First: Some important properties
See MSDN.
Random constructors:
Random(): Initializes a new instance of the Random class, using a time-dependent default seed value.
Random(int seed): Initializes a new instance of the Random class, using the specified seed value.
To improve performance, create one Random object to generate many random numbers over time, instead of repeatedly creating new Random objects to generate one random number, so:
private static Random rand = new Random();
Random methods:
rand.Next(): Returns a positive random number, greater than or equal to zero, less than int.MaxValue.
rand.Next(int max): Returns a positive random number, greater than or equal to zero, less then max, max must be greater than or equal to zero.
rand.Next(int min, int max): Returns a positive random number, greater than or equal to min, less then max, max must be greater than or equal to min.
Homework shows that rand.Next() is about twice as fast as rand.Next(int max).
Second: A solution.
Suppose a positive int has only two bits, forget the sign bit, it's zero, rand.Next() returns three different values with equal probability:
00
01
10
For a true random number the lowest bit is zero as often as it is one, same for the highest bit.
To make it work for the lowest bit use: rand.Next(2)
Suppose an int has three bits, rand.Next() returns seven different values:
000
001
010
011
100
101
110
To make it work for the lowest two bits use: rand.Next(4)
Suppose an int has n bits.
To make it work for n bits use: rand.Next(1 << n)
To make it work for a maximum of 30 bits use: rand.Next(1 << 30)
It's the maximum, 1 << 31 is larger than int.MaxValue.
Which leads to a way to generate a true random uint:
private static uint rnd32()
{
return (uint)(rand.Next(1 << 30)) << 2 | (uint)(rand.Next(1 << 2));
}
A quick check: What's the chance to generate zero?
1 << 2 = 4 = 22, 1 << 30 = 230
The chance for zero is: 1/22 * 1/230 = 1/232
The total number of uints, including zero: 232
It's as clear as daylight, no smog alert, isn't it?
Finally: A misleading idea.
Is it possible to do it faster using rand.Next()
int.Maxvalue is: (2^31)-1
The largest value rand.Next() returns is: (2^31)-2
uint.MaxValue is: (2^32)-1
When rand.Next() is used twice and the results are added, the largest possible value is:
2*((2^31)-2) = (2^32)-4
The difference with uint.MaxValue is:
(2^32)-1 - ((2^32)-4) = 3
To reach uint.MaxValue, another value, rand.Next(4) has to be added, thus we get:
rand.Next() + rand.Next() + rand.Next(4)
What's the chance to generate zero?
Aproximately: 1/231 * 1/231 * 1/4 = 1/264, it should be 1/232
Wait a second, what about:
2 * rand.Next() + rand.Next(4)
Again, what's the chance to generate zero?
Aproximately: 1/231 * 1/4 = 1/233, too small to be truly random.
Another easy example:
rand.Next(2) + rand.Next(2), all possible results:
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 2
Equal probabilities? No way José.
Conclusion: The addition of true random numbers gives a random number, but not a true random number. Throw two fair dice ...

The easiest way to generate random uint:
uint ui = (uint) new Random().Next(-int.MaxValue, int.MaxValue);

Set the Range, " uint u0 <= returned value <= uint u1 ", using System.Random
It is easier to start with a range from "zero" (inclusive) to "u" (inclusive).
You might take a look at my other
answer.
If you are interested in a faster/more efficient way:
Uniform pseudo random numbers in a range. (It is quite a lot of code/text).
Below "rnd32(uint u)" returns: 0 <= value <= u .
The most difficult case is: "u = int.MaxValue". Then the chance that the first iteration of the "do-loops"
(a single iteration of both the outer and the inner "do-loop"), returns a valid value is 50%.
After two iterations, the chance is 75%, etc.
The chance is small that the outer "do-loop" iterates more than one time.
In the case of "u = int.MaxValue": 0%.
It is obvious that: "rnd32(uint u0, uint u1)" returns a value between u0 (incl) and u1 (incl).
private static Random rand = new Random();
private static uint rnd32(uint u) // 0 <= x <= u
{
uint x;
if (u < int.MaxValue) return (uint)rand.Next((int)u + 1);
do
{
do x = (uint)rand.Next(1 << 30) << 2;
while (x > u);
x |= (uint)rand.Next(1 << 2);
}
while (x > u);
return x;
}
private static uint rnd32(uint u0, uint u1) // set the range
{
return u0 < u1 ? u0 + rnd32(u1 - u0) : u1 + rnd32(u0 - u1);
}

Shorely its as simple as this little example with min and max uint range?:
public static class Utility
{
public static uint RandomUInt(uint min, uint max, Random? rand = null)
{
if (min > max) (min, max) = (max, min);
int intMin = (int)(int.MinValue + min);
int intMax = (int)(int.MinValue + max);
int rInt = rand?.Next(intMin, intMax) ?? new Random().Next(intMin, intMax);
return (uint)(int.MaxValue + rInt + 1);
}
}
Utility.RandomUInt(3000000000, 3000000010);
Output:
| 3000000005
| 3000000001
| 3000000009

c# probability and random numbers

I want to trigger an event with a probability of 25% based on a random number generated between 1 and 100 using:
int rand = random.Next(1,100);
Will the following achieve this?
if (rand<=25)
{
// Some event...
}
I thought I would use a number between 1 and 100 so I can tweak the probabilities later on - e.g. adjust to 23% by using
if (rand<=23) {...}

The biggest error you are making is it should be random.Next(0,100) as the documentation states
minValue: The inclusive lower bound of the random number returned.
maxValue: The exclusive upper bound of the random number returned. maxValue must be greater than or equal to minValue.
Emphisis mine, exclusive means it does not include number you passed in, so my code generates the range 0-99 and your code generates the range 1-99.
So change your code to
int rand = random.Next(0,100)
if (rand < 25) //25%
{
// Some event...
}
//other code
if (rand < 23) //23%
{
// Some event...
}
The change from <= to < is because you are now using the exclusive upper bounds range

The second argument of Next(int, int) is the exclusive upper bound of the desired range of results. You should therefore use this:
if (random.Next(0, 100) < 25)
or, if you must use 1-based logic,
if (random.Next(1, 101) <= 25)

You can also use this code (usually for percentage calculations double between 0 and 1 is used):
double rand = random.NextDouble();
if(rand < .25)
{
...

Random.Next returns always the same values [duplicate]

This question already has answers here:
Random number generator only generating one random number
(15 answers)
Closed 9 years ago.
I use the method to generate unique number but I always get the same number -2147483648. Even if I stop the program, recompile it and run again I still see the same number.
public static int GetRandomInt(int length)
{
var min = Math.Pow(10, length - 1);
var max = Math.Pow(10, length) - 1;
var random = new Random();
return random.Next((int)min, (int)max);
}

Try externalizing the random instance:
private readonly Random _random = new Random();
public static int GetRandomInt(int length)
{
var min = Math.Pow(10, length - 1);
var max = Math.Pow(10, length) - 1;
return _random.Next((int)min, (int)max);
}

This is not an issue of not reusing Random instance, the results he gets should be random on multiple starts, not always being -(2^32)
This is the issue with length being too big, and casting powers of length to int. If you break the code into following lines:
var min = Math.Pow(10, length - 1);
var max = Math.Pow(10, length) - 1;
var random = new Random();
var a = (int)min;
var b = (int)max;
return random.Next(a, b);
You'll see that a and b are -2147483648, making that the only possible result of Next(min, max) (the doc specifies if min==max, return min).
The largest length you can safely use with this method is 9. For a length of 10 you'll get System.ArgumentOutOfRangeException, for length > 10 you'll get the -2147483648 result.

You have three problems with your code.
You should externalize your random variable.
You have a problem with truncation error.
The range between min and max is way to large.
The first problem is because you may not have enough time to advance the seed when reinitializing your random variable. The second error comes from truncating your (what would b very large) numbers down to ints. Finally, your biggest problem is your range between your min and your max. Consider finding the range between min and max (as defined in your code) with inputs 1->20:
length max-min
1 8
2 89
3 899
4 8999
5 89999
6 899999
7 8999999
8 89999999
9 899999999
10 8,999,999,999
11 89999999999
12 899999999999
13 8999999999999
14 89999999999999
15 899999999999999
16 9E+15
17 9E+16
18 9E+17
19 9E+18
And keep in mind that the maximum integer is 2,147,483,647, which is passed on any number greater than 9.

You should keep an instance of Random and not new() it up all the time, that should give you better results.
Also check for what length actually is. It may be giving you funny results as to the limits.

I think the problem is the calculation of min and max. They will be greater than Int32.MaxValue pretty fast...

In your class, have one instance of Random, e.g.:
public class MyClass
{
private readonly Random random = new Random();
public static int GetRandomInt(int length)
{
var min = Math.Pow(10, length - 1);
var max = Math.Pow(10, length) - 1;
return random.Next((int)min, (int)max);
}
}
The fact that random always returns the same values only exists for testing purposes.

Random classes usually use a seed to initialize themselves, and will usually return the same sequence provided the seed is the same one :
Always reuse the same Random() instance instead of recreating one over and over again
if you want unpredictable results, use a time-dependent seed rather than an hard-coded one
It's very difficult to code a truly random number generator. Most methods use external entropy generators (such as mouse movement, cpu temperature, or even complex physical mechanisms such as helium balloons colliding one another...).

The Random instance should be created only once and then reused. The reason for this is that the RNG is by default seeded with the current system time. If you rapidly create new Random instances (and pull one value from it) then many of them will be seeded with the same timestamp, because the loop probably executes faster than the system clock advances.
Remember, a RNG initialized by seed A will always return sequence B. So if you create three Random instances all seeded with for example 123, these three instances will always return the same number on the same iteration.