Random Number Generator Class

Question

I've written an abstract class in C# for the purpose of random number generation from an array of bytes. The .NET class RNGCryptoServiceProvider can be used to generate this array of random bytes, for example.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyLibrary
{
    /// <summary>
    /// Represents the abstract base class for a random number generator.
    /// </summary>
    public abstract class Rng
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Rng"/> class.
        /// </summary>
        public Rng()
        {
            //
        }

        public Int16 GetInt16(Int16 min, Int16 max)
        {
            return (Int16)(min + (Int16)(GetDouble() * (max - min)));
        }

        public Int32 GetInt32(Int32 min, Int32 max)
        {
            return (Int32)(min + (Int32)(GetDouble() * (max - min)));
        }

        public Int64 GetInt64(Int64 min, Int64 max)
        {
            return (Int64)(min + (Int64)(GetDouble() * (max - min)));
        }

        public UInt16 GetUInt16(UInt16 min, UInt16 max)
        {
            return (UInt16)(min + (UInt16)(GetDouble() * (max - min)));
        }

        public UInt32 GetUInt32(UInt32 min, UInt32 max)
        {
            return (UInt32)(min + (UInt32)(GetDouble() * (max - min)));
        }

        public UInt64 GetUInt64(UInt64 min, UInt64 max)
        {
            return (UInt64)(min + (UInt64)(GetDouble() * (max - min)));
        }

        public Single GetSingle()
        {
            return (Single)GetUInt64() / UInt64.MaxValue;
        }

        public Double GetDouble()
        {
            return (Double)GetUInt64() / UInt64.MaxValue;
        }

        public Int16 GetInt16()
        {
            return BitConverter.ToInt16(GetBytes(2), 0);
        }

        public Int32 GetInt32()
        {
            return BitConverter.ToInt32(GetBytes(4), 0);
        }

        public Int64 GetInt64()
        {
            return BitConverter.ToInt64(GetBytes(8), 0);
        }

        public UInt16 GetUInt16()
        {
            return BitConverter.ToUInt16(GetBytes(2), 0);
        }

        public UInt32 GetUInt32()
        {
            return BitConverter.ToUInt32(GetBytes(4), 0);
        }

        public UInt64 GetUInt64()
        {
            return BitConverter.ToUInt64(GetBytes(8), 0);
        }

        /// <summary>
        /// Generates random bytes of the specified length.
        /// </summary>
        /// <param name="count">The number of bytes to generate.</param>
        /// <returns>The randomly generated bytes.</returns>
        public abstract byte[] GetBytes(int count);
    }
}

Any suggestions for improvements would be welcome.

Answer 1

I think the design is pretty good. A few comments:

• I'd rename the class to something a bit more descriptive, say RandomGenerator. Then when you implement the class you can declare it with CspGenerator: RandomGenerator or MersenneGenerator: RandomGenerator and it's obvious what the class does.

• Comment the get() methods. IMO all public elements should be documented. Get/set could be left out, but that is a matter of preference. In particular I'd like to know what kind of range min anf max is and is used for.

• Is getBytes() needed externally? If not, I would consider making it class-level rather than public.

The formatting is good - even in Visual Studio I've seen it get messed up as code is refactored and changed.

Answer 2

I think using GetDouble to generate the other random numbers can create performance problems when the user needs efficient random numbers.

Since GetBytes should return a uniform distribution anyway, can’t you bypass using floating-point numbers? See e.g. Java’s Random.nextInt implementation.

Something else, but this may be unnecessary and YAGNI for you: have you considered decoupling the RNG from the probability density function? At the moment your RNG directly supports generating uniformly distributed numbers from within a given range – but it supports no other distributions. This could be off-loaded into a separate Distribution class. For reference, Boost.Random does just that.

Answer 3

If you're planning on placing this in a reusable library you should validate inputs (min > max throws an IndexOutOfRangeException, etc.) Also, you do not need to cast to double in the GetDouble method as the division implicitly returns a double and casting the first operand of the division in GetSingle still causes the division to return a double though you may be sacrificing some precision in the randomness as a result of sacrificing 32bits before you divide.

Otherwise the code does seems as though it would be sufficient. Depending on the scope of your solution perhaps you want to consider min/max overloads for GetSingle and GetDouble and if you're really looking to be special maybe support for System.Numerics.BigInteger and System.Decimal?