public override void CiclicCrossover(IndividualBase parent1, IndividualBase parent2, out IndividualBase child1, out IndividualBase child2) { int[] L1 = (int[])(parent1 as CryptArithmeticSolution).LettersValues.Clone(); int[] L2 = (int[])(parent2 as CryptArithmeticSolution).LettersValues.Clone(); List <int> positionsToShare = new List <int>(); int amountOfChars = charArray.Count(); int itemIdx = Aleatoriety.GetRandomInt(amountOfChars); int tempValue; while (!positionsToShare.Contains(itemIdx)) { positionsToShare.Add(itemIdx); tempValue = L1[itemIdx]; itemIdx = Array.IndexOf(L2, tempValue); } int tempVal; foreach (int position in positionsToShare) { tempVal = L2[position]; L2[position] = L1[position]; L1[position] = tempVal; } child1 = new CryptArithmeticSolution(this, L1); child2 = new CryptArithmeticSolution(this, L2); }
private IndividualBase BestByCrowdedComparison(IndividualBase individual1, IndividualBase individual2) { if (individual1.NonDominationRank < individual2.NonDominationRank) { return(individual1); } if (individual2.NonDominationRank < individual1.NonDominationRank) { return(individual2); } // Se Estão no Mesmo Ranking de Não-Dominância if (individual1.CrowdingDistance > individual2.CrowdingDistance) { return(individual1); } if (individual2.CrowdingDistance > individual1.CrowdingDistance) { return(individual2); } // Se têm a Mesma CrowdingDistance if (Aleatoriety.GetRandomInt(2) == 0) { return(individual1); } else { return(individual2); } }
public void SwapProcessorAt(int index) { int mutationNodeProcessor = GeneticMaterial[1, index]; int differentProcessor; do { differentProcessor = Aleatoriety.GetRandomInt(0, (Problem as TaskSchedulingProblem).ProcessorCount); } while (differentProcessor == mutationNodeProcessor); GeneticMaterial[1, index] = differentProcessor; }
public override void MutateIndividual(IndividualBase individual) { TaskSchedulingSolution schedulingSolution = (individual as TaskSchedulingSolution); int indexA = Aleatoriety.GetRandomInt(TaskCount); int indexB; do { indexB = Aleatoriety.GetRandomInt(TaskCount); } while (indexB == indexA); schedulingSolution.SwapGenesAt(indexA, indexB); schedulingSolution.SwapProcessorAt(indexA); }
public override void PMXCrossover(IndividualBase parent1, IndividualBase parent2, out IndividualBase child1, out IndividualBase child2) { int[,] parent1Scheduling = (parent1 as TaskSchedulingSolution).GeneticMaterial; int[,] parent2Scheduling = (parent2 as TaskSchedulingSolution).GeneticMaterial; int startIdxInclusive = Aleatoriety.GetRandomInt(TaskCount - 1); int endIdxExclusive = Aleatoriety.GetRandomInt(startIdxInclusive + 1, TaskCount + 1); int[,] L1 = new int[2, TaskCount]; int[,] L2 = new int[2, TaskCount]; int L1idx; int L2idx; for (int idx = 0; idx < TaskCount; ++idx) { if ((idx < startIdxInclusive) || (idx >= endIdxExclusive)) { int L1CopyFromTask = parent1Scheduling[0, idx]; int L1CopyFromProcessor = parent1Scheduling[1, idx]; while ((L1idx = IndexOfTaskInInterval(L1CopyFromTask, startIdxInclusive, endIdxExclusive, parent2Scheduling)) != -1) { L1CopyFromTask = parent1Scheduling[0, L1idx]; L1CopyFromProcessor = parent1Scheduling[1, L1idx]; } L1[0, idx] = L1CopyFromTask; L1[1, idx] = L1CopyFromProcessor; int L2CopyFromTask = parent2Scheduling[0, idx]; int L2CopyFromProcessor = parent2Scheduling[1, idx]; while ((L2idx = IndexOfTaskInInterval(L2CopyFromTask, startIdxInclusive, endIdxExclusive, parent1Scheduling)) != -1) { L2CopyFromTask = parent2Scheduling[0, L2idx]; L2CopyFromProcessor = parent2Scheduling[1, L2idx]; } L2[0, idx] = L2CopyFromTask; L2[1, idx] = L2CopyFromProcessor; } else { L1[0, idx] = parent2Scheduling[0, idx]; L1[1, idx] = parent2Scheduling[1, idx]; L2[0, idx] = parent1Scheduling[0, idx]; L2[1, idx] = parent1Scheduling[1, idx]; } } child1 = new TaskSchedulingSolution(this, L1); child2 = new TaskSchedulingSolution(this, L2); }
public TaskSchedulingSolution(ProblemBase problem) : base(problem) { TaskSchedulingProblem schedulingProblem = (Problem as TaskSchedulingProblem); this.GeneticMaterial = new int[2, schedulingProblem.TaskCount]; IEnumerable <int> randomTaskPermutation = Aleatoriety.GetRandomIntegerSequencePermutation(0, schedulingProblem.TaskCount); int idx = 0; foreach (int task in randomTaskPermutation) { this.GeneticMaterial[0, idx] = task; this.GeneticMaterial[1, idx] = Aleatoriety.GetRandomInt(schedulingProblem.ProcessorCount); ++idx; } }
private Population_MultiObjective_AG Procreate(Population_MultiObjective_AG mating) { int expectedChildCount = InitialPopulationSize; Population_MultiObjective_AG newGeneration = new Population_MultiObjective_AG(Problem, expectedChildCount); while (newGeneration.IndividualCount < expectedChildCount) { // Selection Method IndividualBase parent1 = BinaryTournment(mating); IndividualBase parent2 = BinaryTournment(mating); IndividualBase child1 = null, child2 = null; // Crossover Method Problem.PMXCrossover(parent1, parent2, out child1, out child2); for (int i = 0; i < 10; ++i) { if (!newGeneration.Content.Contains(child1) || i == 9) { newGeneration.AddIndividual(child1); break; } } for (int i = 0; i < 10; ++i) { if (!newGeneration.Content.Contains(child2) || i == 9) { newGeneration.AddIndividual(child2); break; } } } foreach (IndividualBase individual in newGeneration.Content) { int aleatoryPercentage = Aleatoriety.GetRandomInt(100); if (aleatoryPercentage < mutationPct) { Problem.MutateIndividual(individual); } Problem.ValidateIndividual(individual); IndividualEvaluator.Execute(individual, Problem); } return(newGeneration); }
public override void MutateIndividual(IndividualBase individual) { CryptArithmeticSolution cryptoSolution = (individual as CryptArithmeticSolution); int amountOfChars = charArray.Count(); int firstPositionIdx = Aleatoriety.GetRandomInt(amountOfChars); int secondPositionIdx; do { secondPositionIdx = Aleatoriety.GetRandomInt(amountOfChars); } while (secondPositionIdx == firstPositionIdx); int tempValue = cryptoSolution.LettersValues[secondPositionIdx]; cryptoSolution.LettersValues[secondPositionIdx] = cryptoSolution.LettersValues[firstPositionIdx]; cryptoSolution.LettersValues[firstPositionIdx] = tempValue; individual = cryptoSolution; }
public IndividualBase GetRandomIndividual() { return(Content[Aleatoriety.GetRandomInt(Content.Count)]); }
public override void EvaluateIndividual(IndividualBase individual) { REDO: TaskSchedulingSolution schedulingSolution = individual as TaskSchedulingSolution; schedulingSolution.SpentPower = 0; double pCommunication = 0; int pTask = 0; bool[] scheduledTasks = new bool[TaskCount]; int remainingTasks = TaskCount; int[] processorsSchedullingTimeForTask = new int[TaskCount]; schedulingSolution.ProcessorStatus = new int[ProcessorCount]; int currentAllocationCost; List <List <TaskIndexingNode> > tasksGroupedByProcessor = GroupTasksByProcessor(schedulingSolution); bool deadLockOcurred; do { for (int currentProcessor = 0; currentProcessor < ProcessorCount; ++currentProcessor) { if (tasksGroupedByProcessor[currentProcessor].Count != 0) { int nextTaskForProcessor = tasksGroupedByProcessor[currentProcessor][0].Task; IEnumerable <int> notScheduledTaskDependencies = CommGraph.GetDirectDependencies(nextTaskForProcessor).Where(Dep => scheduledTasks[Dep] == false); bool readyForScheduling = (notScheduledTaskDependencies.Count() == 0); if (readyForScheduling) { int currentTask = nextTaskForProcessor; currentAllocationCost = schedulingSolution.ProcessorStatus[currentProcessor]; foreach (int dependencyTask in CommGraph.GetDirectDependencies(currentTask)) { int idx = 0; while (schedulingSolution.GeneticMaterial[0, idx] != dependencyTask) { ++idx; } int dependencyProcessor = schedulingSolution.GeneticMaterial[1, idx]; if (dependencyProcessor != currentProcessor) { pCommunication += Math.Pow(CommGraph.GetCommunicationCost(dependencyTask, currentTask), 2); int dependencyCost = processorsSchedullingTimeForTask[dependencyTask] + CommGraph.GetCommunicationCost(dependencyTask, currentTask); if (dependencyCost > currentAllocationCost) { currentAllocationCost = dependencyCost; } } } currentAllocationCost += CommGraph.GetEdgeCost(currentTask); schedulingSolution.ProcessorStatus[currentProcessor] = currentAllocationCost; processorsSchedullingTimeForTask[currentTask] = currentAllocationCost; pTask += CommGraph.GetEdgeCost(currentTask); scheduledTasks[currentTask] = true; tasksGroupedByProcessor[currentProcessor].RemoveAt(0); remainingTasks--; currentProcessor = -1; } } } if (remainingTasks != 0) { deadLockOcurred = true; // Tratamento de DeadLock int chosenSourceProcessor; do { chosenSourceProcessor = Aleatoriety.GetRandomInt(ProcessorCount); } while (tasksGroupedByProcessor[chosenSourceProcessor].Count == 0); int chosenDestProcessor; do { chosenDestProcessor = Aleatoriety.GetRandomInt(ProcessorCount); } while (chosenSourceProcessor == chosenDestProcessor); int taskToBeTransfered = tasksGroupedByProcessor[chosenSourceProcessor].First().Task; int idx = 0; while (schedulingSolution.GeneticMaterial[0, idx] != taskToBeTransfered) { ++idx; } schedulingSolution.GeneticMaterial[1, idx] = chosenDestProcessor; ValidateIndividual(schedulingSolution); goto REDO; } else { deadLockOcurred = false; } } while (deadLockOcurred); // Houve DeadLock schedulingSolution.MakeSpan = schedulingSolution.ProcessorStatus.Max(); schedulingSolution.SpentPower = (pTask * k1) + (pCommunication * k2); }