Example #1
0
        public static ISorter Mutate(this ISorter sorter, IRando rando, StageReplacementMode stageReplacementMode)
        {
            var          mutantIndex    = rando.NextUint(sorter.StageCount);
            var          stageToReplace = sorter[(int)mutantIndex];
            ISorterStage mutantStage    = null;

            switch (stageReplacementMode)
            {
            case StageReplacementMode.RandomReplace:
                mutantStage = rando.ToFullSorterStage(order: sorter.Order, stageNumber: mutantIndex);
                break;

            case StageReplacementMode.RandomRewire:
                mutantStage = rando.RewireSorterStage(stageToReplace);
                break;

            case StageReplacementMode.RandomConjugate:
                mutantStage = stageToReplace.ConjugateByRandomPermutation(rando).ToSorterStage(mutantIndex);
                break;

            case StageReplacementMode.RCTC:
                mutantStage = stageToReplace.ConjugateByRandomSingleTwoCycle(rando).ToSorterStage(mutantIndex);
                break;

            default:
                throw new Exception($"{stageReplacementMode.ToString()}");
            }

            return(sorter.SorterStages.ReplaceAtIndex(mutantIndex, mutantStage)
                   .ToSorter(id: Guid.NewGuid(), genomeId: Guid.Empty));
        }
Example #2
0
        public void TestCompareSortingGaData()
        {
            const int    seed            = 23196;
            const uint   order           = 48;
            const int    stageCount      = 18;
            const int    sorterCount     = 256;
            const int    sortableCount   = 256;
            const double sorterWinRate   = 0.25;
            const double sortableWinRate = 0.75;
            const StageReplacementMode stageReplacementMode = StageReplacementMode.RandomRewire;
            const int  rounds         = 200;
            const uint rollingListCap = 10;

            var randy = Rando.Standard(seed);

            var dsgOld = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );

            var rlSgd = new RollingList <GaSortingData>(rollingListCap);

            for (var i = 0; i < rollingListCap; i++)
            {
                var dsgNew = dsgOld.EvolveSortersDirect(randy);
                rlSgd.Add(dsgNew);
                dsgOld = dsgNew;
            }


            Stopwatch sw = new Stopwatch();

            sw.Start();
            Console.Write($"\n");

            for (var i = 0; i < rounds; i++)
            {
                var dsgNew = dsgOld.EvolveSortersConjSortablesReplace(randy);
                var rl     = rlSgd.Select(sgd => sgd.CompareReport(dsgNew)).ToList();
                foreach (var r in rl)
                {
                    Console.Write($"{r} ");
                }
                Console.Write($"\n");

                dsgOld = dsgNew;
                rlSgd.Add(dsgNew);
            }


            sw.Stop();
            Console.WriteLine("\nElapsed={0}", sw.Elapsed);
        }
Example #3
0
        public void TestRecomboSortingGaData()
        {
            const int    seed            = 23196;
            const uint   order           = 256;
            const int    stageCount      = 20;
            const int    sorterCount     = 128;
            const int    sortableCount   = 128;
            const double sorterWinRate   = 0.25;
            const double sortableWinRate = 0.25;
            const StageReplacementMode stageReplacementMode = StageReplacementMode.RandomRewire;
            const int batchSize   = 10;
            const int batchRounds = 10;

            var randy = Rando.Standard(seed);

            var dsg = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );

            var dsg2 = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );

            Stopwatch sw = new Stopwatch();

            sw.Start();

            for (var j = 0; j < batchRounds; j++)
            {
                for (var i = 0; i < batchSize; i++)
                {
                    dsg = dsg.EvolveSortersConjSortablesReplace(randy);
                    //dsg2 = dsg2.EvolveBothAndRecombineDirect(randy);
                    Console.WriteLine($"{dsg.Report()}"); // { dsg2.Report()}");
                }
            }

            sw.Stop();
            Console.WriteLine("\nElapsed={0}", sw.Elapsed);
        }
Example #4
0
        public static IEnumerable <ISorter> NextGen(this ISorter sorter,
                                                    IRando rando, int childCount, StageReplacementMode stageReplacementMode, bool cloneOrig)
        {
            var mutantCount = (cloneOrig) ? childCount - 1 : childCount;

            if (cloneOrig)
            {
                yield return(sorter);
            }

            for (var i = 0; i < mutantCount; i++)
            {
                yield return(sorter.Mutate(rando, stageReplacementMode));
            }
        }
Example #5
0
        public static GaData ToDirectGaSortingData(
            this IRando randy, uint order,
            uint sorterCount, uint sortableCount, uint stageCount,
            double sorterWinRate, double sortableWinRate,
            StageReplacementMode stageReplacementMode)
        {
            var randomSortablePool = randy.ToRandomSortablePool(order, sortableCount);
            var randomSorterPool   = randy.ToRandomSorterPool(order, stageCount, sorterCount);

            var d = new Dictionary <string, object>();

            d.SetCurrentStep(0);
            d.SetSeed(randy.NextInt());
            d.SetSorterWinRate(sorterWinRate);
            d.SetSortableWinRate(sortableWinRate);
            d.SetSortablePool(randomSortablePool);
            d.SetSorterPool(randomSorterPool);
            d.SetStageReplacementMode(stageReplacementMode);

            return(new GaData(d));
        }
Example #6
0
 public static void SetStageReplacementMode(this Dictionary <string, object> dictionary,
                                            StageReplacementMode stageReplacementMode)
 {
     dictionary[kStageReplacementMode] = stageReplacementMode;
 }
Example #7
0
        public void TestToRandomStageDimerGaData256()
        {
            const uint   order           = 256;
            const int    stageCount      = 24;
            const int    sorterCount     = 512;
            const int    sortableCount   = 8;
            const double sorterWinRate   = 0.25;
            const double sortableWinRate = 0.25;
            const StageReplacementMode stageReplacementMode = StageReplacementMode.RandomRewire;
            const int batchSize   = 5;
            const int batchRounds = 2;

            const int seed  = 75319;
            var       randy = Rando.Standard(seed);

            var dga1 = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );

            var dga2 = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );
            var dga3 = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );
            var dga4 = randy.ToDirectGaSortingData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate,
                stageReplacementMode: stageReplacementMode
                );



            var sdgca1 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca2 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca3 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca4 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sw = new Stopwatch();

            sw.Start();

            for (var j = 0; j < batchRounds; j++)
            {
                for (var i = 0; i < batchSize; i++)
                {
                    dga1 = dga1.EvolveSortersConjSortablesReplace(randy);
                    dga2 = dga2.EvolveSortersConjSortablesReplace(randy);
                    dga3 = dga3.EvolveSortersConjSortablesReplace(randy);
                    dga4 = dga4.EvolveSortersConjSortablesReplace(randy);


                    sdgca1 = sdgca1.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca2 = sdgca2.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca3 = sdgca3.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca4 = sdgca4.EvolveSorterStageDimerConjRecomb_SortableConj(randy);

                    Console.WriteLine($"{dga1.Report()} {dga2.Report()} " +
                                      $"{dga3.Report()} {dga4.Report()} " +
                                      $"{sdgca1.Report()} {sdgca2.Report()} " +
                                      $"{sdgca3.Report()} {sdgca4.Report()} ");
                }
            }

            sw.Stop();
            Console.WriteLine("\nElapsed={0}", sw.Elapsed);
        }
Example #8
0
        public void TestToRandomStageDimerGaDataVaryPoolSizes()
        {
            const uint   order           = 128;
            const int    stageCount      = 18;
            const int    sorterCount     = 256;
            const int    sortableCount   = 32;
            const double sorterWinRate   = 0.25;
            const double sortableWinRate = 0.25;
            const StageReplacementMode stageReplacementMode = StageReplacementMode.RandomRewire;
            const int batchSize   = 10;
            const int batchRounds = 200;

            const int seed  = 75333;
            var       randy = Rando.Standard(seed);


            var sdgca1 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca2 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount * 2,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca3 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount,
                sortableCount: sortableCount * 4,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sdgca4 = randy.ToStageDimerGaData(
                order: order,
                sorterCount: sorterCount / 2,
                sortableCount: sortableCount * 4,
                stageCount: stageCount,
                sorterWinRate: sorterWinRate,
                sortableWinRate: sortableWinRate
                );

            var sw = new Stopwatch();

            sw.Start();

            for (var j = 0; j < batchRounds; j++)
            {
                for (var i = 0; i < batchSize * 2; i++)
                {
                    sdgca1 = sdgca1.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca2 = sdgca2.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca3 = sdgca3.EvolveSorterStageDimerConjRecomb_SortableConj(randy);
                    sdgca4 = sdgca4.EvolveSorterStageDimerConjRecomb_SortableConj(randy);

                    Console.WriteLine(
                        $"{sdgca1.Report()} {sdgca2.Report()} " +
                        $"{sdgca3.Report()} {sdgca4.Report()} ");
                }
            }

            sw.Stop();
            Console.WriteLine("\nElapsed={0}", sw.Elapsed);
        }