Add uniform random number generator. (#54)

* Add RNG.

* Improve RNG and test.

* Fix.

* Add next for int64/uint64.

* Fix uniform for real number.

* Clean up.

Author: Alinshans

src/MineCase.Algorithm/UniformRNG.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MineCase.Algorithm
+{
+    public struct UniformRNG
+    {
+        // https://en.wikipedia.org/wiki/Linear_congruential_generator
+        // MMIX by Donald Knuth
+        private static readonly ulong _multiplier = 6364136223846793005;
+        private static readonly ulong _increment = 1442695040888963407;
+
+        private ulong _state;
+
+        public UniformRNG(ulong state)
+        {
+            if (state == 0)
+            {
+                var time = DateTime.Now;
+                var seed = (ulong)(time.Day << 25 | time.Hour << 20 | time.Minute << 14 | time.Second << 8 | time.Millisecond);
+                for (int i = 0; i < 4; ++i)
+                {
+                    seed = seed * _multiplier + _increment;
+                }
+
+                _state = seed;
+            }
+            else
+            {
+                _state = state;
+            }
+        }
+
+        public int NextInt32()
+        {
+            return (int)Next();
+        }
+
+        public uint NextUInt32()
+        {
+            return Next();
+        }
+
+        public long NextInt64()
+        {
+            Next();
+            return (long)_state;
+        }
+
+        public ulong NextUInt64()
+        {
+            Next();
+            return _state;
+        }
+
+        public float NextSingle()
+        {
+            return Next() * 2.3283064365386962890625e-10f;
+        }
+
+        public double NextDouble()
+        {
+            var t = Next();
+            return (((ulong)t << 32) | Next()) * 5.4210108624275221700372640043497e-20;
+        }
+
+        public int Uniform(int a, int b)
+        {
+            return a == b ? a : (int)(Next() % (b - a) + a);
+        }
+
+        public uint Uniform(uint a, uint b)
+        {
+            return a == b ? a : Next() % (b - a) + a;
+        }
+
+        public long Uniform(long a, long b)
+        {
+            return a == b ? a : Next() % (b - a) + a;
+        }
+
+        public ulong Uniform(ulong a, ulong b)
+        {
+            return a == b ? a : Next() % (b - a) + a;
+        }
+
+        public float Uniform(float a, float b)
+        {
+            return NextSingle() * (b - a) + a;
+        }
+
+        public double Uniform(double a, double b)
+        {
+            return NextDouble() * (b - a) + a;
+        }
+
+        private uint Next()
+        {
+            _state = _state * _multiplier + _increment;
+            return (uint)_state;
+        }
+    }
+}

tests/UnitTest/RNGTest.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ImageSharp;
+using MineCase.Algorithm;
+using Xunit;
+
+namespace MineCase.UnitTest
+{
+    public class RNGTest
+    {
+        public readonly string RootDir;
+
+        public RNGTest()
+        {
+            RootDir = SetRootDir();
+        }
+
+        private static string SetRootDir([CallerFilePath]string fileName = null) =>
+            Path.Combine(Path.GetDirectoryName(fileName), "bin");
+
+        [Fact]
+        public void TestNext()
+        {
+            var rng = new UniformRNG(0);
+            int first = rng.NextInt32(), second = rng.NextInt32();
+            for (int i = 0; i < 1000000; ++i)
+            {
+                first = second;
+                second = rng.NextInt32();
+                Assert.NotEqual(first, second);
+            }
+        }
+
+        [Fact]
+        public void TestUniform()
+        {
+            var rng = new UniformRNG(0);
+
+            var i1 = rng.Uniform(1, 2);
+            Assert.Equal(1, i1);
+            var i2 = rng.Uniform(1U, 2U);
+            Assert.Equal(1U, i2);
+            var i3 = rng.Uniform(1.0f, 1.0f);
+            Assert.Equal(1.0f, i3);
+            var i4 = rng.Uniform(1.0, 1.0);
+            Assert.Equal(1.0, i4);
+        }
+
+        [Fact]
+        public void TestFrequencyImg()
+        {
+            var rng = new UniformRNG(0);
+            int[] bucket = new int[100];
+
+            const int xExtent = 100;
+            const int yExtent = 200;
+
+            using (var file = File.OpenWrite(Path.Combine(RootDir, "rng_frequency.bmp")))
+            using (var image = new Image<ImageSharp.PixelFormats.Rgb24>(xExtent, yExtent))
+            {
+                for (int i = 0; i < 10000; ++i)
+                {
+                    bucket[rng.Uniform(0, xExtent)]++;
+                }
+
+                for (int i = 0; i < xExtent; ++i)
+                {
+                    for (int j = 0; j < bucket[i]; ++j)
+                    {
+                        image[i, yExtent - j] = new ImageSharp.PixelFormats.Rgb24(0xFF, 0x69, 0xB4);
+                    }
+                }
+
+                image.SaveAsBmp(file);
+            }
+        }
+
+        [Fact]
+        public void TesIntNoiseImg()
+        {
+            var rng = new UniformRNG(0);
+
+            const int xExtent = 100;
+            const int yExtent = 100;
+
+            using (var file = File.OpenWrite(Path.Combine(RootDir, "rng_int_noise.bmp")))
+            using (var image = new Image<ImageSharp.PixelFormats.Rgb24>(xExtent, yExtent))
+            {
+                for (int i = 0; i < xExtent; ++i)
+                {
+                    for (int j = 0; j < yExtent; ++j)
+                    {
+                        var color = (byte)rng.Uniform(0, 255);
+                        image[i, j] = new ImageSharp.PixelFormats.Rgb24(color, color, color);
+                    }
+                }
+
+                image.SaveAsBmp(file);
+            }
+        }
+
+        [Fact]
+        public void TesFloatNoiseImg()
+        {
+            var rng = new UniformRNG(0);
+
+            const int xExtent = 100;
+            const int yExtent = 100;
+
+            using (var file = File.OpenWrite(Path.Combine(RootDir, "rng_float_noise.bmp")))
+            using (var image = new Image<ImageSharp.PixelFormats.Rgb24>(xExtent, yExtent))
+            {
+                for (int i = 0; i < xExtent; ++i)
+                {
+                    for (int j = 0; j < yExtent; ++j)
+                    {
+                        var color = (byte)(rng.Uniform(0.0f, 2.55f) * 100);
+                        image[i, j] = new ImageSharp.PixelFormats.Rgb24(color, color, color);
+                    }
+                }
+
+                image.SaveAsBmp(file);
+            }
+        }
+
+        [Fact]
+        public void TesDoubleNoiseImg()
+        {
+            var rng = new UniformRNG(0);
+
+            const int xExtent = 100;
+            const int yExtent = 100;
+
+            using (var file = File.OpenWrite(Path.Combine(RootDir, "rng_double_noise.bmp")))
+            using (var image = new Image<ImageSharp.PixelFormats.Rgb24>(xExtent, yExtent))
+            {
+                for (int i = 0; i < xExtent; ++i)
+                {
+                    for (int j = 0; j < yExtent; ++j)
+                    {
+                        var color = (byte)(rng.Uniform(0.0, 2.55) * 100);
+                        image[i, j] = new ImageSharp.PixelFormats.Rgb24(color, color, color);
+                    }
+                }
+
+                image.SaveAsBmp(file);
+            }
+        }
+    }
+}