RandomSeed.cs

using MPewsey.Common.Mathematics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
 
namespace MPewsey.Common.Random
{
    [DataContract(Namespace = Constants.DataContractNamespace)]
    public class RandomSeed
    {
        public static RandomSeed Current { get; } = new RandomSeed();
 
        [DataMember(Order = 1)]
        public int Seed { get; private set; }
 
        [DataMember(Order = 2)]
        private int Position1 { get; set; }
 
        [DataMember(Order = 3)]
        private int Position2 { get; set; }
 
        [DataMember(Order = 4)]
        private int[] Seeds { get; set; } = new int[56];
 
        public RandomSeed()
        {
            SetSeed(Environment.TickCount);
        }
 
        public RandomSeed(int seed)
        {
            SetSeed(seed);
        }
 
        private RandomSeed(RandomSeed other)
        {
            Seed = other.Seed;
            Position1 = other.Position1;
            Position2 = other.Position2;
            Seeds = new int[other.Seeds.Length];
            Array.Copy(other.Seeds, Seeds, other.Seeds.Length);
        }
 
        public override string ToString()
        {
            return $"RandomSeed(Seed = {Seed})";
        }
 
        public RandomSeed Copy()
        {
            return new RandomSeed(this);
        }
 
        private static int Mod(int value)
        {
            if (value < 0)
                return value + int.MaxValue;
            return value;
        }
 
        private static int WrapIndex(int value)
        {
            if (value > 55)
                return 1;
            return value;
        }
 
        public void SetSeed(int seed)
        {
            Seed = seed;
            Position1 = 0;
            Position2 = 21;
            var mj = seed == int.MinValue ? int.MaxValue : Math.Abs(seed);
            mj = 161803398 - mj;
            Seeds[55] = mj;
            var mk = 1;
 
            // Populate random seed array.
            for (int i = 1; i < 55; i++)
            {
                var index = 21 * i % 55;
                Seeds[index] = mk;
                mk = Mod(mj - mk);
                mj = Seeds[index];
            }
 
            // Generate random numbers to reduce seed bias.
            for (int k = 1; k < 5; k++)
            {
                for (int i = 1; i < 56; i++)
                {
                    Seeds[i] = Mod(Seeds[i] - Seeds[1 + (i + 30) % 55]);
                }
            }
        }
 
        public int Next()
        {
            var i = WrapIndex(Position1 + 1);
            var j = WrapIndex(Position2 + 1);
            var next = Mod(Seeds[i] - Seeds[j]);
 
            if (next == int.MaxValue)
                next--;
 
            Seeds[i] = next;
            Position1 = i;
            Position2 = j;
            return next;
        }
 
        public int Next(int maxValue)
        {
            return (int)(NextDouble() * maxValue);
        }
 
        public int Next(int minValue, int maxValue)
        {
            var delta = maxValue - (long)minValue;
            var t = delta <= int.MaxValue ? NextDouble() : NextLargeDouble();
            return (int)((long)(t * delta) + minValue);
        }
 
        public float NextFloat()
        {
            return (float)NextDouble();
        }
 
        public float NextFloat(float maxValue)
        {
            return (float)NextDouble(maxValue);
        }
 
        public float NextFloat(float minValue, float maxValue)
        {
            return (float)NextDouble(minValue, maxValue);
        }
 
        public double NextDouble()
        {
            return Next() / (double)int.MaxValue;
        }
 
        public double NextDouble(double maxValue)
        {
            return NextDouble() * maxValue;
        }
 
        public double NextDouble(double minValue, double maxValue)
        {
            var x = NextDouble();
            return x * maxValue + (1 - x) * minValue;
        }
 
        public (float x, float y) FloatInsideUnitCircle()
        {
            var (x, y) = DoubleInsideUnitCircle();
            return ((float)x, (float)y);
        }
 
        public (double x, double y) DoubleInsideUnitCircle()
        {
            var radius = Math.Sqrt(NextDouble());
            var angle = NextDouble(2 * Math.PI);
            var x = radius * Math.Cos(angle);
            var y = radius * Math.Sin(angle);
            return (x, y);
        }
 
        private double NextLargeDouble()
        {
            var next = Next();
 
            if (Next() % 2 == 0)
                next = -next;
 
            double result = next;
            result += int.MaxValue - 1;
            result /= 2.0 * int.MaxValue - 1;
            return result;
        }
 
        public void Shuffle<T>(IList<T> list)
        {
            for (int i = 0; i < list.Count - 1; i++)
            {
                var j = Next(i, list.Count);
                (list[i], list[j]) = (list[j], list[i]);
            }
        }
 
        public List<T> Shuffled<T>(IEnumerable<T> collection)
        {
            var copy = new List<T>(collection);
            Shuffle(copy);
            return copy;
        }
 
        private int DrawIndex(IList<double> totals)
        {
            if (totals.Count > 0)
            {
                var value = NextDouble(totals[totals.Count - 1]);
 
                for (int i = 0; i < totals.Count; i++)
                {
                    if (value <= totals[i] && totals[i] > 0)
                        return i;
                }
            }
 
            return -1;
        }
 
        public int DrawWeightedIndex(IList<double> weights)
        {
            if (weights.Count > 0)
            {
                var totals = new List<double>(weights.Count);
                return DrawWeightedIndex(weights, totals);
            }
 
            return -1;
        }
 
        public int DrawWeightedIndex(IList<float> weights)
        {
            if (weights.Count > 0)
            {
                var totals = new List<double>(weights.Count);
                return DrawWeightedIndex(weights, totals);
            }
 
            return -1;
        }
 
        public int DrawWeightedIndex(IList<double> weights, List<double> totals)
        {
            Maths.CumSum(weights, totals);
            return DrawIndex(totals);
        }
 
        public int DrawWeightedIndex(IList<float> weights, List<double> totals)
        {
            Maths.CumSum(weights, totals);
            return DrawIndex(totals);
        }
 
        public List<int> DrawWeightedIndexes(IList<double> weights, int count, bool withReplacement)
        {
            if (withReplacement)
                return DrawWeightedIndexesWithReplacement(weights, count);
 
            return DrawWeightedIndexesWithoutReplacement(weights, count);
        }
 
        private List<int> DrawWeightedIndexesWithReplacement(IList<double> weights, int count)
        {
            var result = new List<int>(count);
 
            if (weights.Count > 0)
            {
                var totals = Maths.CumSum(weights);
 
                for (int i = 0; i < count; i++)
                {
                    var index = DrawIndex(totals);
 
                    if ((uint)index < (uint)weights.Count)
                        result.Add(index);
                }
            }
 
            return result;
        }
 
        private List<int> DrawWeightedIndexesWithoutReplacement(IList<double> weights, int count)
        {
            count = Math.Min(count, weights.Count);
            var result = new List<int>(count);
 
            if (weights.Count > 0)
            {
                var weightsCopy = weights.ToArray();
                var totals = new List<double>(weightsCopy.Length);
 
                for (int i = 0; i < count; i++)
                {
                    var index = DrawWeightedIndex(weightsCopy, totals);
 
                    if ((uint)index < (uint)weightsCopy.Length)
                    {
                        weightsCopy[index] = 0;
                        result.Add(index);
                    }
                }
            }
 
            return result;
        }
 
        public List<int> DrawWeightedIndexes(IList<float> weights, int count, bool withReplacement)
        {
            if (withReplacement)
                return DrawWeightedIndexesWithReplacement(weights, count);
 
            return DrawWeightedIndexesWithoutReplacement(weights, count);
        }
 
        private List<int> DrawWeightedIndexesWithReplacement(IList<float> weights, int count)
        {
            var result = new List<int>(count);
 
            if (weights.Count > 0)
            {
                var totals = Maths.CumSum(weights);
 
                for (int i = 0; i < count; i++)
                {
                    var index = DrawIndex(totals);
 
                    if ((uint)index < (uint)weights.Count)
                        result.Add(index);
                }
            }
 
            return result;
        }
 
        private List<int> DrawWeightedIndexesWithoutReplacement(IList<float> weights, int count)
        {
            count = Math.Min(count, weights.Count);
            var result = new List<int>(count);
 
            if (weights.Count > 0)
            {
                var weightsCopy = weights.ToArray();
                var totals = new List<double>(weightsCopy.Length);
 
                for (int i = 0; i < count; i++)
                {
                    var index = DrawWeightedIndex(weightsCopy, totals);
 
                    if ((uint)index < (uint)weightsCopy.Length)
                    {
                        weightsCopy[index] = 0;
                        result.Add(index);
                    }
                }
            }
 
            return result;
        }
 
        public bool ChanceSatisfied(double chance)
        {
            return (NextDouble() <= chance && chance > 0) || chance >= 1;
        }
    }
}