/// <summary>
/// 获取随机数算法
/// </summary>
/// <param name="type">算法类型</param>
/// <returns>随机数算法</returns>
private IRandom GetRandom(RandomTypes type)
{
IRandom random;
if (!randomsCache.TryGetValue(type, out random))
{
randomsCache[type] = random = Make(type);
}
return(random);
}
/// <summary>
/// 生成随机算法
/// </summary>
/// <returns>随机数算法</returns>
public IRandom Make(int seed, RandomTypes type)
{
Func <int, IRandom> builder;
IRandom result;
if (!randomsMaker.TryGetValue(type, out builder) ||
(result = builder.Invoke(seed)) == null)
{
throw new NotImplementedException("RandomTypes [" + type + "] is not implemented");
}
return(result);
}
private void TestRandomNext(RandomTypes type)
{
var env = MakeEnv();
var factory = env.Make <IRandomFactory>();
var random = factory.Make(type);
Assert.AreNotEqual(random.Next(), random.Next());
Assert.AreNotEqual(random.Next(1000000000), random.Next(1000000000));
for (var i = 0; i < 100; i++)
{
Assert.AreEqual(true, random.Next(100) <= 100);
}
Assert.AreNotEqual(random.Next(100, 200000000), random.Next(100, 200000000));
for (var i = 0; i < 100; i++)
{
var v = random.Next(100, 200);
Assert.AreEqual(true, v >= 100 && v <= 200);
}
var b = new byte[10];
random.NextBytes(b);
var sum = 0;
for (var i = 0; i < 10; i++)
{
sum += b[i];
}
Assert.AreEqual(true, sum > 0);
Assert.AreNotEqual(random.NextDouble(), random.NextDouble());
for (var i = 0; i < 100; i++)
{
var v = random.NextDouble();
Assert.AreEqual(true, v >= 0 && v <= 1);
}
}
public Random(RandomTypes type, uint seed)
{
Handle = TCOD_random_new_from_seed(type, seed);
}
public Random(RandomTypes type)
{
Handle = TCOD_random_new(type);
}
private extern static IntPtr TCOD_random_new_from_seed(RandomTypes type, uint seed);
private extern static IntPtr TCOD_random_new(RandomTypes type);
/// <summary>
/// 返回一个随机数
/// </summary>
/// <param name="type">使用的随机算法类型</param>
/// <returns>随机数</returns>
public int Next(RandomTypes type)
{
var random = GetRandom(type);
return(random.Next());
}
/// <summary>
/// 生成随机算法
/// </summary>
/// <param name="type">算法类型</param>
/// <returns>随机数算法</returns>
public IRandom Make(RandomTypes type)
{
return(Make(Util.MakeSeed(), type));
}
/// <summary>
/// 构造一个随机算法生成器
/// </summary>
/// <param name="defaultType">默认的随机算法类型</param>
public RandomFactory(RandomTypes defaultType)
{
defaultRandomType = defaultType;
}
/// <summary>
/// 注册随机数算法
/// </summary>
/// <param name="type">算法类型</param>
/// <param name="builder">构建器</param>
public void RegisterRandom(RandomTypes type, Func <int, IRandom> builder)
{
Guard.Requires <ArgumentNullException>(type != null);
Guard.Requires <ArgumentNullException>(builder != null);
randomsMaker.Add(type, builder);
}
/// <summary>
/// 返回一个介于0到1之间的随机数
/// </summary>
/// <param name="type">使用的随机算法类型</param>
/// <returns>随机数</returns>
public double NextDouble(RandomTypes type)
{
var random = GetRandom(type);
return(random.NextDouble());
}
/// <summary>
/// 生成随机数填充流
/// </summary>
/// <param name="buffer">流</param>
/// <param name="type">使用的随机算法类型</param>
public void NextBytes(byte[] buffer, RandomTypes type)
{
var random = GetRandom(type);
random.NextBytes(buffer);
}
/// <summary>
/// 返回一个随机数
/// </summary>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <param name="type">使用的随机算法类型</param>
/// <returns>随机数</returns>
public int Next(int minValue, int maxValue, RandomTypes type)
{
var random = GetRandom(type);
return(random.Next(minValue, maxValue));
}
