Exemplo n.º 1
0
        public static LCG GetShuffleFunction(
            BigInteger deckSize,
            IList <ShuffleInstruction> shuffleInstructions)
        {
            // Combine all shuffle instructions into one LCG
            var result           = LCG.GetIdentity(deckSize);
            var dealIntoNewStack = GetShuffleFunctionDealIntoNewStack(deckSize);

            foreach (var shuffleInstruction in shuffleInstructions)
            {
                if (ShuffleTechnique.DealIntoNewStack.Equals(shuffleInstruction.Technique))
                {
                    result = LCG.Compose(result, dealIntoNewStack);
                }
                else if (ShuffleTechnique.CutNCards.Equals(shuffleInstruction.Technique))
                {
                    var cutNCards = GetShuffleFunctionCutNCards(shuffleInstruction.ShuffleParameter, deckSize);
                    result = LCG.Compose(result, cutNCards);
                }
                else if (ShuffleTechnique.DealWithIncrementN.Equals(shuffleInstruction.Technique))
                {
                    var dealWithIncrementN = GetShuffleFunctionDealWithIncrementN(shuffleInstruction.ShuffleParameter, deckSize);
                    result = LCG.Compose(result, dealWithIncrementN);
                }
            }
            return(result);
        }
Exemplo n.º 2
0
        public static BigInteger ShuffleCard(
            BigInteger startCardIndex,
            BigInteger deckSize,
            BigInteger numberOfShuffles,
            IList <ShuffleInstruction> shuffleInstructions,
            bool runBackwards)
        {
            var shuffleFunction = GetShuffleFunction(deckSize, shuffleInstructions);

            // Compose the shuffle function into itself once for each shuffle pass
            shuffleFunction = ExponentiationHelper.GetExponentiationByPowers(
                x: shuffleFunction,
                exponent: numberOfShuffles,
                MultiplyFunction: LCG.Compose,
                identity: LCG.GetIdentity(deckSize));
            // If we are running backwards, then use the inverse of the
            // shuffle function
            if (runBackwards)
            {
                shuffleFunction = shuffleFunction.GetInverse();
            }
            var endCardIndex = shuffleFunction.Evaluate(startCardIndex);

            return(endCardIndex);
        }
Exemplo n.º 3
0
 public void Initialize(LCG random, InteractiveDungeonObject interactiveObjectContainer, SpawnableContainer spawnKeyframes,
                        TrapContainer trapContainer, MapPainter mapPainter)
 {
     _timer  = new Timer();
     _random = random;
     _interactiveObjectContainer = interactiveObjectContainer;
     _spawnKeyframes             = spawnKeyframes;
     _trapContainer = trapContainer;
     _mapPainter    = mapPainter;
 }
Exemplo n.º 4
0
        public void LCG_Next_Test()
        {
            LCG  target = new LCG();
            uint max    = 10;

            target.Srand(2);
            uint result = target.Next(max);

            Assert.IsTrue(result >= 0, "Wartosc losowa LCG jest mniejsza od 0!");
            Assert.IsTrue(result <= max, "Wartosc losowa LCG jest większa niż podana wartość maksymalna!");
        }
Exemplo n.º 5
0
 public DRandom(bool useLCGenerator, bool fixedRange, int minValue, int maxValue)
 {
     useLCG = useLCGenerator;
     if (useLCG)
     {
         generator = new LCG();
     }
     isFixedRange = fixedRange;
     if (isFixedRange)
     {
         if (minValue > maxValue)
         {
             throw new ArgumentException("Error:  Invalid arguments for DRandom(): minValue cannot be greater than maxValue.");
         }
         fixedRangeSamples = new int[SAMPLE_SIZE];
         fixedRangeMin     = minValue;
         fixedRangeMax     = maxValue;
     }
     GenerateSamples();
 }
Exemplo n.º 6
0
 public DRandom(bool useLCGenerator, bool fixedRange, int minValue, int maxValue)
 {
     useLCG = useLCGenerator;
     if (useLCG)
     {
         generator = new LCG();
     }
     isFixedRange = fixedRange;
     if (isFixedRange)
     {
         if (minValue > maxValue)
         {
             throw new ArgumentException("Error:  Invalid arguments for DRandom(): minValue cannot be greater than maxValue.");
         }
         fixedRangeSamples = new int[SAMPLE_SIZE];
         fixedRangeMin = minValue;
         fixedRangeMax = maxValue;
     }
     GenerateSamples();
 }
        public void LCGCorrectness()
        {
            var lcg = new LCG(123, 456, 1);

            Assert.Equal(579u, lcg.Next());
            Assert.Equal(71673u, lcg.Next());
            Assert.Equal(8816235u, lcg.Next());
            Assert.Equal(1084397361u, lcg.Next());
            Assert.Equal(236889683u, lcg.Next());
            Assert.Equal(3367627689u, lcg.Next());
            Assert.Equal(1901345787u, lcg.Next());
            Assert.Equal(1937298273u, lcg.Next());
            Assert.Equal(2064486755u, lcg.Next());
            Assert.Equal(528800857u, lcg.Next());
            Assert.Equal(617996427u, lcg.Next());
            Assert.Equal(2999116945u, lcg.Next());
            Assert.Equal(3819164531u, lcg.Next());
            Assert.Equal(1605802505u, lcg.Next());
            Assert.Equal(4240180251u, lcg.Next());
            Assert.Equal(1851128513u, lcg.Next());

            lcg.Seed(2);

            Assert.Equal(702u, lcg.Next());
            Assert.Equal(86802u, lcg.Next());
            Assert.Equal(10677102u, lcg.Next());
            Assert.Equal(1313284002u, lcg.Next());
            Assert.Equal(2620142750u, lcg.Next());
            Assert.Equal(155011506u, lcg.Next());
            Assert.Equal(1886546510u, lcg.Next());
            Assert.Equal(116987202u, lcg.Next());
            Assert.Equal(1504524414u, lcg.Next());
            Assert.Equal(372909650u, lcg.Next());
            Assert.Equal(2918214446u, lcg.Next());
            Assert.Equal(2458091746u, lcg.Next());
            Assert.Equal(1697574494u, lcg.Next());
            Assert.Equal(2643233010u, lcg.Next());
            Assert.Equal(2995113486u, lcg.Next());
            Assert.Equal(3326739074u, lcg.Next());
        }
        public void GetExponentiationByPowersLCFTest()
        {
            var testData = new List <Tuple <LCG, BigInteger, Func <LCG, LCG, LCG>, LCG> >()
            {
                // f(f(f(x))) where f(x) = 2*x + 3 (mod 5)
                // f(f(f(x)))   = f(f(2x + 3))
                //              = f(2*(2x + 3) + 3)
                //              = f(4x + 6 + 3)
                //              = f(4x + 9)
                //              = 2*(4x + 9) + 3
                //              = 8x + 18 + 3
                //              = 8x + 21 (mod 5)
                Tuple.Create(
                    new LCG(2, 3, 5),
                    (BigInteger)0,
                    (Func <LCG, LCG, LCG>)LCG.Compose,
                    LCG.GetIdentity(5)),
                Tuple.Create(
                    new LCG(2, 3, 5),
                    (BigInteger)1,
                    (Func <LCG, LCG, LCG>)LCG.Compose,
                    new LCG(2, 3, 5)),
                Tuple.Create(
                    new LCG(2, 3, 5),
                    (BigInteger)3,
                    (Func <LCG, LCG, LCG>)LCG.Compose,
                    new LCG(8, 21, 5)),
            };

            foreach (var testExample in testData)
            {
                var result = ExponentiationHelper.GetExponentiationByPowers <LCG>(
                    x: testExample.Item1,
                    exponent: testExample.Item2,
                    MultiplyFunction: testExample.Item3,
                    identity: LCG.GetIdentity(testExample.Item1.M));
                Assert.Equal(testExample.Item4, result);
            }
        }
Exemplo n.º 9
0
Arquivo: Map.cs Projeto: jaoel/LD44
    public Map(Tilemap floors, Tilemap walls, Tilemap pits, LCG random)
    {
        _drawCells     = true;
        _drawDelaunay  = false;
        _drawGabriel   = false;
        _drawEMST      = false;
        _drawCorridors = true;
        _drawLayout    = true;
        _drawBounds    = false;

        _floors = floors;
        _walls  = walls;
        _pits   = pits;
        _random = random;

        InteractiveObjects = new List <GameObject>();
        Enemies            = new List <GameObject>();
        ChokePoints        = new List <BoundsInt>();
        StartToGoalPath    = new List <LineSegment2D>();

        CollisionMapCollider = GameObject.Find("CollisionMap").GetComponent <TilemapCollider2D>();
    }
Exemplo n.º 10
0
        private static void Main(string[] args)
        {
            var random = new System.Random(1234);

            Vector3 GetPoint()
            {
                float Get()
                {
                    return((float)Math.Round((1.0d - 2.0d * random.NextDouble()) * 10));
                }

                return(new Vector3(Get(), Get(), Get()));
            }

            var points = Enumerable.Range(0, 10000).Select(s => GetPoint()).ToArray();


            var numEdges    = OrientedBoundingBox.NumEdges;
            var numFaces    = OrientedBoundingBox.NumFaces;
            var numVertices = OrientedBoundingBox.NumVertices;

#if UNITY_EDITOR || UNITY
            var box = new OrientedBoundingBox(Vector3.zero, Vector3.zero, Vector3.right, Vector3.up, Vector3.forward);
#else
            var box = new OrientedBoundingBox(Vector3.Zero, Vector3.Zero, Vector3.Right, Vector3.Up, Vector3.Forward);
#endif

            foreach (var point in points)
            {
                box.Enclose(point);
            }

#if UNITY_EDITOR || UNITY
            var b1 = box.Contains(Vector3.zero);
#else
            var b1 = box.Contains(Vector3.Zero);
#endif
            var b2 = box.Contains(new Vector3(100, 100, 100));
            var c1 = box.CornerPoint(0);
            var c2 = box.CornerPoint(7);
            var f1 = box.FacePoint(0, 0.0f, 0.0f);
            var f2 = box.FacePoint(0, 1.0f, 1.0f);
            var p1 = box.PointInside(0.0f, 0.0f, 0.0f);
            var p2 = box.PointInside(1.0f, 1.0f, 1.0f);
            var p3 = box.PointInside(0.5f, 0.5f, 0.5f);

#if UNITY_EDITOR || UNITY
            box.Translate(Vector3.one * +2);
            box.Translate(Vector3.one * -2);
            box.Scale(Vector3.zero, Vector3.one * 0.5f);
            box.Scale(Vector3.zero, Vector3.one * 2.0f);
            var d1 = box.Distance(Vector3.one * 20.0f);
            var d2 = box.Distance(Vector3.one * 30.0f);
#else
            box.Translate(Vector3.One * +2);
            box.Translate(Vector3.One * -2);
            box.Scale(Vector3.Zero, Vector3.One * 0.5f);
            box.Scale(Vector3.Zero, Vector3.One * 2.0f);
            var d1 = box.Distance(Vector3.One * 20.0f);
            var d2 = box.Distance(Vector3.One * 30.0f);
#endif
            var e1 = box.PointOnEdge(0, 0.0f);
            var e2 = box.PointOnEdge(0, 1.0f);
            var e3 = box.PointOnEdge(0, 0.5f);
            var l1 = box.Edge(0);
            var l2 = box.Edge(1);
            var m1 = box.WorldToLocal();
            var m2 = box.LocalToWorld();
            var n1 = box.FacePlane(0);
            var n2 = box.FacePlane(1);
            var x1 = OrientedBoundingBox.OptimalEnclosing(points);
            var x2 = OrientedBoundingBox.BruteEnclosing(points);

            LCG lcg = new LCG();
            lcg.IntFast();
            lcg.Float();
            lcg.Int();
            lcg.Int(0, 10);

#if UNITY_EDITOR || UNITY
            OrientedBoundingBox obb = new OrientedBoundingBox(Vector3.zero, Vector3.one, Vector3.right, Vector3.up, Vector3.forward);
#else
            OrientedBoundingBox obb = new OrientedBoundingBox(Vector3.Zero, Vector3.One, Vector3.Right, Vector3.Up, Vector3.Forward);
#endif
            obb.RandomPointOnSurface(lcg);
        }
Exemplo n.º 11
0
        static void Main()
        {
            while (true) // Continue the game untill the user does want to anymore...
            {
                int   threads      = 3;
                int   threadLoad   = 10;
                ulong initialValue = 7;
                int   Method       = 1;

                Console.WriteLine("Usage: Threads <num> Load <num> Seed <num> Method <num>");
                Console.WriteLine("Method: 0-Tree,1-Leapfrog,2-Modified Leapfrog. Argument+1 - speedtest.");
                String[] args = Console.ReadLine().Split(' ');

                bool test_threads = int.TryParse(args[0], out threads);
                bool test_load    = int.TryParse(args[1], out threadLoad);
                bool test_seed    = ulong.TryParse(args[2], out initialValue);
                bool test_Method  = int.TryParse(args[3], out Method);

                if (test_threads == false || test_load == false || test_seed == false || test_Method == false)
                {
                    System.Console.WriteLine("Please enter a numeric argument.");
                    System.Console.WriteLine("Usage: Threads <num> Load <num> Seed <num> Method <num>");
                }

                // One event is used for each Fibonacci object

                //LCGLeapfrog[] LCGLeapfrogArray = new LCGLeapfrog[threads];
                TimeSpan?start = DateTime.Now.TimeOfDay;
                TimeSpan?end   = null;
                if (Method == 1)
                {
                    ManualResetEvent[] doneEvents = new ManualResetEvent[threads];

                    LCGLeapfrog[] lcgArray = new LCGLeapfrog[threads];

                    //Pradinė seka iš n-gijų sk. narių
                    LCGLeapfrog initialSeq = new LCGLeapfrog(initialValue, threads);
                    initialSeq.Calculateinitial(threads);


                    for (int i = 0; i < threads; i++)
                    {
                        doneEvents[i] = new ManualResetEvent(false);

                        //Inicializuojam su pradinės sekos nariais
                        //laipsnį n parenkam > gijų sk., kad sekos nesidublikuotu
                        ulong       seed = initialSeq.Result[i];
                        LCGLeapfrog f    = new LCGLeapfrog(seed, threadLoad, threads, doneEvents[i]);

                        lcgArray[i] = f;
                        ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
                    }
                    WaitHandle.WaitAll(doneEvents);
                    Console.WriteLine("All calculations are complete.");

                    // Display the results...
                    for (int i = 0; i < threads; i++)
                    {
                        LCGLeapfrog f = lcgArray[i];
                        for (int j = 0; j < f.Result.Length; j++)
                        {
                            Console.WriteLine("Thread({0}) = {1}", i, f.Result[j]);
                        }
                    }
                }
                else if (Method == 0)
                {
                    ManualResetEvent[] doneEvents = new ManualResetEvent[threads];
                    LCG[] lcgArray = new LCG[threads];

                    //Sugeneruojam pradinę seką su n-gijų skaičius narių

                    LCG2 initialSeq = new LCG2(initialValue, threads);
                    initialSeq.Calculateinitial(threads);

                    //Kiekvienai gijai, generuojam naują seką,
                    //pradines reikšmes parinkdami iš pradinės sekos

                    for (int i = 0; i < threads; i++)
                    {
                        doneEvents[i] = new ManualResetEvent(false);

                        //Pradinė reikšmė
                        ulong seed = initialSeq.Result[i];

                        //Generuojam seką
                        LCG f = new LCG(seed, threadLoad, doneEvents[i]);
                        lcgArray[i] = f;

                        ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
                    }

                    // Wait for all threads in pool to calculation...
                    WaitHandle.WaitAll(doneEvents);
                    Console.WriteLine("All calculations are complete.");

                    // Display the results...
                    for (int i = 0; i < threads; i++)
                    {
                        LCG f = lcgArray[i];
                        for (int j = 0; j < f.Result.Length; j++)
                        {
                            Console.WriteLine("Thread({0}) = {1}", i, f.Result[j]);
                        }
                    }
                }
                else if (Method == 2)
                {
                    ManualResetEvent[] doneEvents = new ManualResetEvent[threads];
                    LCG[] lcgArray = new LCG[threads];

                    //Pradinė seka su tarpais n-narių kiekis sekoje
                    LCGLeapfrog initialSeq = new LCGLeapfrog(initialValue, threads, threadLoad);
                    initialSeq.Calculateinitial(threads);


                    for (int i = 0; i < threads; i++)
                    {
                        doneEvents[i] = new ManualResetEvent(false);

                        //Pradinės reikšmės iš išretintos sekos
                        //Toliau kiekviena gija generuoja nuosekliai
                        ulong seed = initialSeq.Result[i];
                        LCG   f    = new LCG(seed, threadLoad, doneEvents[i]);
                        lcgArray[i] = f;

                        ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
                    }

                    WaitHandle.WaitAll(doneEvents);
                    Console.WriteLine("All calculations are complete.");

                    // Display the results...
                    for (int i = 0; i < threads; i++)
                    {
                        LCG f = lcgArray[i];
                        for (int j = 0; j < f.Result.Length; j++)
                        {
                            Console.WriteLine("Thread({0}) = {1}", i, f.Result[j]);
                        }
                    }
                }
                else if (Method == 11)
                {
                    TimeSpan?previousTime = null;
                    for (int k = 1; k < threads; k++)
                    {
                        start = DateTime.Now.TimeOfDay;
                        ManualResetEvent[] doneEvents = new ManualResetEvent[k];
                        LCGLeapfrog[]      lcgArray   = new LCGLeapfrog[k];
                        LCGLeapfrog        initialSeq = null;
                        initialSeq = new LCGLeapfrog(initialValue, k);
                        initialSeq.Calculateinitial(k);
                        Console.WriteLine("launching {0} tasks...", k);
                        for (int i = 0; i < k; i++)
                        {
                            doneEvents[i] = new ManualResetEvent(false);
                            ulong seed = 0;
                            seed = initialSeq.Result[i];
                            LCGLeapfrog f = new LCGLeapfrog(seed, threadLoad / k, k, doneEvents[i]);
                            lcgArray[i] = f;
                            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
                        }
                        WaitHandle.WaitAll(doneEvents);
                        end = DateTime.Now.TimeOfDay;
                        if (previousTime != null)
                        {
                            Console.WriteLine("Speedup: {0}%", ((previousTime.Value.TotalMilliseconds / (end - start).Value.TotalMilliseconds) - 1) * 100);
                        }
                        previousTime = end - start;
                        Console.WriteLine("Time taken: {0}", previousTime);
                    }
                }
                else if (Method == 21)
                {
                    TimeSpan?previousTime = null;
                    for (int k = 1; k < threads; k++)
                    {
                        ManualResetEvent[] doneEvents = new ManualResetEvent[k];
                        LCG[]       lcgArray          = new LCG[k];
                        LCGLeapfrog initialSeq        = null;
                        initialSeq = new LCGLeapfrog(initialValue, k, threadLoad / k);
                        initialSeq.Calculateinitial(k);
                        Console.WriteLine("launching {0} tasks...", k);
                        for (int i = 0; i < k; i++)
                        {
                            doneEvents[i] = new ManualResetEvent(false);
                            ulong seed = 0;
                            seed = initialSeq.Result[i];
                            LCG f = new LCG(seed, threadLoad / k, doneEvents[i]);
                            lcgArray[i] = f;
                            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
                        }
                        WaitHandle.WaitAll(doneEvents);
                        Console.WriteLine("All calculations are complete.");

                        end = DateTime.Now.TimeOfDay;
                        if (previousTime != null)
                        {
                            Console.WriteLine("Speedup: {0}%", ((previousTime.Value.TotalMilliseconds / (end - start).Value.TotalMilliseconds) - 1) * 100);
                        }
                        previousTime = end - start;
                        Console.WriteLine("Time taken: {0}", previousTime);
                    }
                }

                end = DateTime.Now.TimeOfDay;
                Console.WriteLine("Time taken: {0}", end - start);
                while (true) // Continue asking until a correct answer is given.
                {
                    Console.Write("Do you want to play again [Y/N]?");
                    string answer = Console.ReadLine().ToUpper();
                    if (answer == "Y")
                    {
                        break; // Exit the inner while-loop and continue in the outer while loop.
                    }
                    if (answer == "N")
                    {
                        return; // Exit the Main-method.
                    }
                }
                //Console.ReadKey();
            }
        }
Exemplo n.º 12
0
        public void RandomToFile(int seed, int range, int numberOfPRNGs)
        {
            String         file           = "";
            StringBuilder  stringBuilder  = new StringBuilder();
            String         content        = "";
            AbstractRandom randomAbstract = new LCG();
            Random         random         = new Random(seed);

            TimerManager.ClearMessage();

            for (int i = 0; i < 3; i++)
            {
                stringBuilder.Clear();
                if (i == 0)
                {
                    randomAbstract = new LCG();
                    randomAbstract.Srand((uint)seed);
                    file = "Pseudo Random Numbers LCG.csv";
                }
                else if (i == 1)
                {
                    randomAbstract = new LFG();
                    randomAbstract.Srand((uint)seed);
                    file = "Pseudo Random Numbers LFG.csv";
                }
                else if (i == 2)
                {
                    randomAbstract = new MSM();
                    randomAbstract.Srand((uint)seed);
                    file = "Pseudo Random Numbers MSM.csv";
                }

                TimerManager.TimerStart(file);

                for (int j = 0; j < numberOfPRNGs; j++)
                {
                    stringBuilder.Append(randomAbstract.Next((uint)range));
                    stringBuilder.Append(Environment.NewLine);
                }

                TimerManager.TimrStop();

                content = stringBuilder.ToString();
                WriteToFile(file, content);
            }

            file = "Pseudo Random Numbers Random C#.csv";
            stringBuilder.Clear();

            TimerManager.TimerStart(file);

            for (int j = 0; j < numberOfPRNGs; j++)
            {
                stringBuilder.Append(random.Next(range));
                stringBuilder.Append(Environment.NewLine);
            }

            TimerManager.TimrStop();

            MessageBox.Show("Pliki zostały wygenerowane.", "Generowanie plików");

            content = stringBuilder.ToString();
            WriteToFile(file, content);
        }