コード例 #1
0
        public void PMXmultiThread()
        {
            String          FileName                = "C:\\Studia\\Genetic-multi-tasks\\GeneticMultiTask\\TSP instances\\br17.xml";
            XDocument       tspXmlFile              = XDocument.Load(FileName);
            AdjacencyMatrix matrix                  = new AdjacencyMatrix(tspXmlFile);
            MultiThreadInversionMutation pmx        = new MultiThreadInversionMutation(1);
            MultiTaskGeneticSolver       solver     = new MultiTaskGeneticSolver(matrix, pmx, null, null, 100, 0);
            List <Candidate>             population = randomPopulation(50);

            pmx.MutateList(population);
        }
コード例 #2
0
        internal GeneticSolver createNewSolver(bool isMultiThread)
        {
            MutationType    mutation  = null;
            CrossoverType   crossover = null;
            SelectionType   selection = null;
            GeneticSolver   solver    = null;//add parameters TO DO
            AdjacencyMatrix matrix    = new AdjacencyMatrix(tspXmlFile);

            switch (mutationIndex)
            {
            case 0:
            {
                if (!isMultiThread)
                {
                    mutation = new InversionMutation(mutationChance);
                }
                else
                {
                    mutation = new MultiThreadInversionMutation(mutationChance);
                }
                break;
            }

            case 1:
            {
                if (!isMultiThread)
                {
                    mutation = new TranspositionMutation(mutationChance);
                }
                else
                {
                    mutation = new MultiThreadTranspositionMutation(mutationChance);
                }
                break;
            }
            }

            switch (crossoverIndex)
            {
            case 0:
            {
                if (!isMultiThread)
                {
                    crossover = new PMXCrossover(crossoverChance);
                }
                else
                {
                    crossover = new MultiThreadPMXCrossover(crossoverChance);          //new PMXCrossover(crossoverChance); //
                }
                break;
            }

            case 1:
            {
                if (!isMultiThread)
                {
                    crossover = new OXCrossover(crossoverChance);
                }
                else
                {
                    crossover = new MultiThreadOXCrossover(crossoverChance);
                }
                break;
            }
            }

            switch (selectorIndex)
            {
            case 0:
            {
                if (!isMultiThread)
                {
                    selection = new TournamentSelection(selectorSize);
                }
                else
                {
                    selection = new MultiThreadTournamentSelection(selectorSize);
                }
                break;
            }

            case 1:
            {
                if (!isMultiThread)
                {
                    selection = new RouletteSelection(selectorSize);
                }
                else
                {
                    selection = new MultiThreadRouletteSelection(selectorSize);
                }
                break;
            }
            }

            if (mutation != null && selection != null && crossover != null)
            {
                if (isMultiThread)
                {
                    MultiTaskOptions.parallelOptCrossover.MaxDegreeOfParallelism = int.Parse(View.tbxLvlCrossover.Text);
                    MultiTaskOptions.parallelOptMutation.MaxDegreeOfParallelism  = int.Parse(View.tbxLvlMutation.Text);
                    MultiTaskOptions.parallelOptSelection.MaxDegreeOfParallelism = int.Parse(View.tbxLvlSelector.Text);
                    solver = new MultiTaskGeneticSolver(matrix, mutation, crossover, selection, populationSize, timeMS);
                }
                else
                {
                    solver = new SingleTaskGeneticSolver(matrix, mutation, crossover, selection, populationSize, timeMS);
                }
            }
            return(solver);
        }