(u)int64和decimal的(伪)随机约束值的生成

假设您知道如何生成n个随机位。这两种方法都很容易做到 NextBytes 或重复呼叫 Random.Next 有适当的限制。

要在正确的范围内生成long/ulong,请计算范围有多大,以及表示该范围需要多少位。然后可以使用拒绝抽样,这将 在最坏的时候 拒绝生成的值的一半(例如,如果您想要一个在[0,128]范围内的值,这意味着您将多次生成[0,255]。如果您想要一个非零的范围,只需计算出范围的大小,在[0,size]中生成一个随机值,然后添加基数。

生成一个随机的小数是非常困难的,我相信-除了其他的,你必须指定你想要的分布。

应该这样做。对于decimal,我使用jon skeet的初始方法生成随机的 decimal S(无约束)。为了 long 我提供了一种产生随机非负的方法 长的 s,用于在随机范围内创建a值。

注意这是为了 十进制的 结果分布不是 [minValue, maxValue] . 它只是在范围内所有小数的位表示上是一致的。 [最小值,最大值] . 如果不使用拒绝抽样,我看不到一个简单的解决方法。

为了 长的 结果分布在 [minValue, maxValue) .

static class RandomExtensions {
    static int NextInt32(this Random rg) {
        unchecked {
            int firstBits = rg.Next(0, 1 << 4) << 28;
            int lastBits = rg.Next(0, 1 << 28);
            return firstBits | lastBits;
        }
    }

    public static decimal NextDecimal(this Random rg) {
        bool sign = rg.Next(2) == 1;
        return rg.NextDecimal(sign);
    }

    static decimal NextDecimal(this Random rg, bool sign) {
        byte scale = (byte)rg.Next(29);
        return new decimal(rg.NextInt32(),
                           rg.NextInt32(),
                           rg.NextInt32(),
                           sign,
                           scale);
    }

    static decimal NextNonNegativeDecimal(this Random rg) {
        return rg.NextDecimal(false);
    }

    public static decimal NextDecimal(this Random rg, decimal maxValue) {
        return (rg.NextNonNegativeDecimal() / Decimal.MaxValue) * maxValue; ;
    }

    public static decimal NextDecimal(this Random rg, decimal minValue, decimal maxValue) {
        if (minValue >= maxValue) {
            throw new InvalidOperationException();
        }
        decimal range = maxValue - minValue;
        return rg.NextDecimal(range) + minValue;
    }

    static long NextNonNegativeLong(this Random rg) {
        byte[] bytes = new byte[sizeof(long)];
        rg.NextBytes(bytes);
        // strip out the sign bit
        bytes[7] = (byte)(bytes[7] & 0x7f);
        return BitConverter.ToInt64(bytes, 0);
    }

    public static long NextLong(this Random rg, long maxValue) {
        return (long)((rg.NextNonNegativeLong() / (double)Int64.MaxValue) * maxValue);
    }

    public static long NextLong(this Random rg, long minValue, long maxValue) {
        if (minValue >= maxValue) {
            throw new InvalidOperationException();
        }
        long range = maxValue - minValue;
        return rg.NextLong(range) + minValue;
    }
}

我来这里寻找一种在任意范围内生成64位值的方法。其他答案在给定范围(例如long.minvalue到long.maxvalue)时无法生成随机数。这是我的版本,似乎可以解决问题:

public static long NextInt64(this Random random, long minValue, long maxValue)
{
    Contract.Requires(random != null);
    Contract.Requires(minValue <= maxValue);
    Contract.Ensures(Contract.Result<long>() >= minValue &&
                     Contract.Result<long>() < maxValue);

    return (long)(minValue + (random.NextUInt64() % ((decimal)maxValue - minValue)));
}

它使用以下扩展方法:

public static ulong NextUInt64(this Random random)
{
    Contract.Requires(random != null);

    return BitConverter.ToUInt64(random.NextBytes(8), 0);
}

public static byte[] NextBytes(this Random random, int byteCount)
{
    Contract.Requires(random != null);
    Contract.Requires(byteCount > 0);
    Contract.Ensures(Contract.Result<byte[]>() != null &&
                     Contract.Result<byte[]>().Length == byteCount);

    var buffer = new byte[byteCount];
    random.NextBytes(buffer);
    return buffer;
}

即使请求范围的大小不是2^64的干净除数,分布也不完美,但它至少为任何给定范围提供了请求范围内的随机数。

根据乔恩·斯基特的方法,我想说的是:

public static long NextLong(this Random rnd, long min, long max) 
{
    if (max <= min) 
    {
        throw new Exception("Min must be less than max.");
    }

    long dif = max - min;

    var bytes = new byte[8];
    rnd.NextBytes(bytes);
    bytes[7] &= 0x7f; //strip sign bit

    long posNum = BitConverter.ToInt64(bytes, 0);
    while (posNum > dif)
    {
        posNum >>= 1;
    }

    return min + posNum;
}

如果发现任何错误,请通知我。

long posNum = BitConverter.ToInt64(Guid.NewGuid().ToByteArray(), 0); 


 use this instead of NextBytes