public void Setup() { rng = new PcgRandom(); Console.WriteLine($"Setup with value {ValueToDivideBy}"); divisorBranching = new UInt32Divisor(ValueToDivideBy); divisorOld = new OldDivisor(ValueToDivideBy); }
public static void LoadGame() { if (!File.Exists(Constants.SAVE_FILE)) { NewGame(); } System.Diagnostics.Debug.WriteLine("Reading saved file"); try { using (Stream saveFile = File.OpenRead(Constants.SAVE_FILE)) { BinaryFormatter deserializer = new BinaryFormatter(); World = (WorldHandler)deserializer.Deserialize(saveFile); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine($"Load failed: {ex.Message}"); NewGame(); } // TODO: restore rng to saved position Random = new PcgRandom(Option.FixedSeed ? Option.Seed : (int)DateTime.Now.Ticks); VisualRandom = new PcgRandom(Random.Next()); StateHandler.Reset(); }
public void Reseed() { Assert.Equal((int)(TestValues[0] % int.MaxValue), _rng.Next()); _rng = new PcgRandom(42); Assert.Equal((int)(TestValues[0] % int.MaxValue), _rng.Next()); }
public static int NextBinomial(this PcgRandom rand, int n, double p) { if (n <= 30) { // Run Bernouilli samples for small n. int successes = 0; for (int i = 0; i < n; i++) { if (rand.NextDouble() < p) { successes++; } } return(successes); } else { // Approximate with the normal distribution for large n. int normal = (int)rand.NextNormal(n * p, n * p * (1 - p)); if (normal < 0) { return(0); } else if (normal > n) { return(n); } else { return(normal); } } }
public static double NextGamma(this PcgRandom rand, double a, double b) { // Marsaliga and Tsang - assumes a > 0 if (a < 1) { return(rand.NextGamma(1.0 + a, b) * Math.Pow(rand.NextDouble(), 1.0 / a)); } double d = a - 1.0 / 3.0; double c = 1.0 / Math.Sqrt(9.0 * d); double z, u, v; do { do { z = rand.NextNormal(0, 1.0); v = 1.0 + c * z; }while (v <= 0); v = v * v * v; u = rand.NextDouble(); if (u < 1 - 0.0331 * z * z * z * z) { break; } }while (Math.Log(u) >= 0.5 * z * z + d * (1 - v + Math.Log(v))); return(d * v / b); }
public LognormalDistribution(SimSharp.Simulation environment, double mean, double std, int seed) { _environment = environment; _rng = new PcgRandom(seed); Mean = mean; StdDev = std; }
//주어진 필드의 크기와 지뢰 갯수로 필드 생성 public void InitMineField(int width = ConstantsPack.minWidthCells, int height = ConstantsPack.minHeightCells, int mines = ConstantsPack.minMines) { fieldState = ConstantsPack.gameState.gameState_Init; fieldWidth = width; fieldHeight = height; fieldMines = mines; remainSafeCells = (fieldWidth * fieldHeight) - fieldMines; fieldGrid = new FieldCell[fieldHeight, fieldWidth]; PcgRandom randObj = new PcgRandom(); //주어진 지뢰 갯수로 필드에 지뢰를 임의로 배치시킨다. int remainMines = fieldMines; while (remainMines > 0) { int setX = randObj.Next(0, fieldWidth); int setY = randObj.Next(0, fieldHeight); if (fieldGrid[setY, setX].openValue == (sbyte)ConstantsPack.openCellValue.cellValue_mine) { continue; } fieldGrid[setY, setX].openValue = (sbyte)ConstantsPack.openCellValue.cellValue_mine; remainMines--; } //배치가 끝나면 빈 칸들을 탐색하여 주변 지뢰가 있으면 그 갯수를 체크한다. int x = 0, y = 0, k = 0; for (y = 0; y < fieldHeight; ++y) { for (x = 0; x < fieldWidth; ++x) { FieldCell curCell = fieldGrid[y, x]; if (curCell.openValue == (sbyte)ConstantsPack.openCellValue.cellValue_blank) { //빈 칸 주변 8셀에 지뢰가 있는지 체크하여 카운팅 sbyte totalAdjMines = 0; for (k = 0; k < 8; ++k) { int adjX = x + adjDx[k], adjY = y + adjDy[k]; if (!CellRangeCheck(adjX, adjY)) { continue; } if (fieldGrid[adjY, adjX].openValue == (sbyte)ConstantsPack.openCellValue.cellValue_mine) { totalAdjMines++; } } //카운팅된 값을 셀에 대입 fieldGrid[y, x].openValue = totalAdjMines; } } } //필드 생성 끝나면 인게임 상태로 전환 fieldState = ConstantsPack.gameState.gameState_InGame; } //InitMineField 함수 끝
protected MapGenerator(int width, int height, IEnumerable <LevelId> exits, PcgRandom random) { Width = width; Height = height; Exits = exits; Rand = random; Map = new MapHandler(width, height); }
public TriangularDistribution(SimSharp.Simulation environment, double low, double high, double mode, int seed) { _environment = environment; _rng = new PcgRandom(seed); Low = low; High = high; Mode = mode; }
public static double NextNormal(this PcgRandom rand, double mean, double variance) { // Box-Muller transform double u1 = 1.0 - rand.NextDouble(); double u2 = 1.0 - rand.NextDouble(); double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2); return(mean + (Math.Sqrt(variance) * randStdNormal)); }
private void InitializeWorldState() { var rand = new Random(settings.Seed); var initRand = new PcgRandom(rand.Next()); craneRNG = new PcgRandom(rand.Next()); productionRNG = new PcgRandom(rand.Next()); handoverRNG = new PcgRandom(rand.Next()); readyRNG = new PcgRandom(rand.Next()); var capacity = World.Buffers.Sum(x => x.MaxHeight); var past = sim.Now; for (var i = 0; i < settings.InitialNumberOfBlocks; i++) { past -= sim.RandLogNormal2(initRand, settings.ArrivalTimeMean, settings.ArrivalTimeStd); var b = new Block() { Id = ++blockIds, Release = ToTimeStamp(past), Ready = false, Due = ToTimeStamp(past + sim.RandLogNormal2(initRand, settings.DueTimeMean, settings.DueTimeStd)) }; while (b.Due < ToTimeStamp(sim.Now + settings.DueTimeMin)) { b.Due += sim.RandLogNormal2(initRand, settings.DueTimeMean, settings.DueTimeStd); } var readyFactor = settings.ReadyFactorMin + initRand.NextDouble() * (settings.ReadyFactorMax - settings.ReadyFactorMin); b.Ready = (b.Release + TimeSpan.FromSeconds(readyFactor * (b.Due - b.Release).TotalSeconds)) < Now; var possibleBuffers = World.Buffers.Where(x => x.BottomToTop.Count < x.MaxHeight).ToList(); var buf = possibleBuffers[initRand.Next(possibleBuffers.Count)]; if (buf.BottomToTop.Count == 0) { buf.BottomToTop.Add(b); } else { buf.BottomToTop.Insert(0, b); } sim.Process(BlockProcess(b, suppressEvent: true)); } BufferUtilization.UpdateTo(World.Buffers.Sum(x => x.Height) / (double)World.Buffers.Sum(x => x.MaxHeight)); World.KPIs.BufferUtilizationMean = BufferUtilization.Mean; World.Production.BottomToTop.Add(new Block() { Id = ++blockIds, Release = ToTimeStamp(sim.Now), Ready = false, Due = ToTimeStamp(sim.Now + sim.RandLogNormal2(initRand, settings.DueTimeMean, settings.DueTimeStd)) }); World.Handover.Ready = true; sim.Process(BlockProcess(World.Production.BottomToTop.Single(), suppressEvent: true)); sim.Process(WorldUpdates()); }
public void PcgReproducibilityTest() { var pcg = new PcgRandom(15); var seq = Enumerable.Range(0, 1000).Select(x => pcg.Next()).ToArray(); Thread.Sleep(100); pcg = new PcgRandom(15); var seq2 = Enumerable.Range(0, 1000).Select(x => pcg.Next()).ToArray(); Assert.Equal(seq, seq2); }
public void MulHiEqualsUnsigned() { var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var a = rng.Next(); var b = rng.Next(); Assert.AreEqual(MultiplyHigh32(a, b), MultiplyHighCustom32(a, b), $"Testing {a} * {b}"); } }
private ulong Random64(PcgRandom gen) { var int1 = (ulong)gen.Next(); var int2 = (ulong)gen.Next(); ulong result = int1 << 32; result += int2; return(result); }
public void CorrectlyDividesRandomNumerators(long divisor) { var int64Divisor = new Int64Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = unchecked (rng.Next() | ((long)rng.Next() << 32)); var quotient = testDividend / int64Divisor; Assert.AreEqual(testDividend / divisor, quotient, $"Trying to test {testDividend} / {divisor}"); } }
public void CorrectlyDividesRandomNumerators(uint divisor) { var uInt32Divisor = new UInt32Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = rng.Next(); var quotient = testDividend / uInt32Divisor; Assert.AreEqual(testDividend / divisor, quotient, $"Trying to test {testDividend} / {divisor}"); } }
public void CalculatesAbsFloorCorrectlyRandomNumerators(long divisor) { var int64Divisor = new Int64Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = unchecked (rng.Next() | ((long)rng.Next() << 32)); var rounded = int64Divisor.AbsFloor(testDividend); Assert.AreEqual(testDividend / divisor * divisor, rounded, $"Trying to test {testDividend} / {divisor} * {divisor}"); } }
public void CalculatesModulusCorrectlyRandomNumerators(long divisor) { var int64Divisor = new Int64Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = unchecked (rng.Next() | ((long)rng.Next() << 32)); var remainder = testDividend % int64Divisor; Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {divisor}"); } }
public void CalculatesModulusCorrectlyRandomNumerators(uint divisor) { var uInt32Divisor = new UInt32Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = rng.Next(); var remainder = testDividend % uInt32Divisor; Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {divisor}"); } }
public void CalculatesFloorCorrectlyRandomNumerators(uint divisor) { var uInt32Divisor = new UInt32Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = rng.Next(); var rounded = uInt32Divisor.Floor(testDividend); Assert.AreEqual(testDividend / divisor * divisor, rounded, $"Trying to test {testDividend} / {divisor} * {divisor}"); } }
public void DivRemReturnsCorrectlyRandomNumerators(long divisor) { var int64Divisor = new Int64Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = unchecked (rng.Next() | ((long)rng.Next() << 32)); var remainder = int64Divisor.DivRem(testDividend, out var quotient); Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {divisor}"); Assert.AreEqual(testDividend / divisor, quotient, $"Trying to test {testDividend} / {divisor}"); } }
public void CalculatesAbsFloorRemCorrectlyRandomNumerators(int divisor) { var int32Divisor = new Int32Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = unchecked ((int)rng.Next()); var remainder = int32Divisor.AbsFloorRem(testDividend, out var rounded); Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {divisor}"); Assert.AreEqual(testDividend / divisor * divisor, rounded, $"Trying to test {testDividend} / {divisor} * {divisor}"); } }
public static Option <T> Random <T>(this IEnumerable <T> enumerable, PcgRandom rand) { var list = enumerable.ToList(); if (list.Count == 0) { return(Option.None <T>()); } else { return(Option.Some(list[rand.Next(list.Count)])); } }
public void DivRemReturnsCorrectlyRandomNumerators(uint divisor) { var uInt32Divisor = new UInt32Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = rng.Next(); var remainder = uInt32Divisor.DivRem(testDividend, out var quotient); Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {divisor}"); Assert.AreEqual(testDividend / divisor, quotient, $"Trying to test {testDividend} / {divisor}"); } }
public void CalculatesFloorRemCorrectlyRandomNumerators(ulong divisor) { var uInt64Divisor = new UInt64Divisor(divisor); var rng = new PcgRandom(); for (ulong i = 0; i < RandomTestCount; i++) { var testDividend = rng.Next() | ((ulong)rng.Next() << 32); var remainder = uInt64Divisor.FloorRem(testDividend, out var rounded); Assert.AreEqual(testDividend % divisor, remainder, $"Trying to test {testDividend} % {SerializeDivisor(uInt64Divisor)}"); Assert.AreEqual(testDividend / divisor * divisor, rounded, $"Trying to test {testDividend} / {SerializeDivisor(uInt64Divisor)} * {SerializeDivisor(uInt64Divisor)}"); } }
public override void LoadContent(InitState state) { base.LoadContent(state); ScreenSize = new Point(renderTarget.Width, renderTarget.Height); State = GameState.GameOver; Random = new PcgRandom(new Random().Next()); score1 = score2 = 0; ScoreText1 = ScoreText2 = "Score: 0"; ballSize = 6; ballSize2 = ballSize * 0.5f; paddleSize = new Point(8, 32); paddleSize2 = new Vector2(paddleSize.X * 0.5f, paddleSize.Y * 0.5f); paddleSpeed = 3; paddleIndent = 4; GameScreenY = 16; velInc = 0.2f; cpu1 = cpu2 = true; }
public override void LoadContent(InitState state) { base.LoadContent(state); renderer = (TotalRoboRenderer)Renderer; // todo - create rendertarget 304x255 ScreenSize = new Point(renderTarget.Width, renderTarget.Height); State = GameState.GameOver; Random = new PcgRandom(new Random().Next()); wave = 0; score = 0; ScoreText = "0"; entityData = new EntityData[(int)EntityType.zLast]; entityData[1].Speed = 1; entityData[2].Speed = 6; entityData[3].Speed = 0.3f; Entities = new Entity[100]; Entities[0].Type = EntityType.Player; }
public static void NewGame() { Random = new PcgRandom(Option.FixedSeed ? Option.Seed : (int)DateTime.Now.Ticks); VisualRandom = new PcgRandom(Random.Next()); Player = new Player(new ActorParameters("Player") { Awareness = 10, MaxHp = 100, MaxSp = 50 }); StateHandler.Reset(); MessageHandler.Clear(); EventScheduler.Clear(); Overlay.Clear(); Threatened.Clear(); Animations.Clear(); WorldParameter worldParameter = Program.LoadData <WorldParameter>("world"); World = new WorldHandler(worldParameter); World.Initialize(); }
internal static void SetRandomState(uint state) { s_Random = new PcgRandom(state); }
public BspMapGenerator(int width, int height, IEnumerable <LevelId> exits, PcgRandom random) : base(width, height, exits, random) { }