public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
if (chromosome.Sections.Length < 2)
{
return(null);
}
int retryCount = ParameterSet.GetInt(ParameterNames.FailedMutationRetryCount);
while (true)
{
var source = GetSourceSectionAndPosition(chromosome);
bool success = ReplaceOneGeneToRandomSection(chromosome, source, retryCount);
if (success || retryCount-- < 0)
{
break;
}
}
CleanOutSections(chromosome);
return(chromosome);
}
public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
if (chromosome.Sections.Length < 2)
{
return(null);
}
bool childConflicted = false;
int retryCount = ParameterSet.GetInt(ParameterNames.FailedMutationRetryCount);
while (true)
{
var range1 = GetSourceRange(chromosome);
var section1 = chromosome.Sections[range1.Section];
var sourceGeneValue1 = section1[range1.FirstPosition];
var sourceGeneValue2 = section1[range1.LastPosition - 1];
var targetSectionIndex = Random.GetIntWithTabu(0, chromosome.Sections.Length, range1.Section);
var section2 = chromosome.Sections[targetSectionIndex];
var targetPosition1 = FindNewGenePosition(section2, sourceGeneValue1);
var targetPosition2 = FindNewGenePosition(section2, sourceGeneValue2);
var range2 = new GeneRange(targetSectionIndex, targetPosition1, targetPosition2);
var temp1 = MergeSections(section1, range1, section2, range2, ref childConflicted);
var temp2 = MergeSections(section2, range2, section1, range1, ref childConflicted);
if (!childConflicted)
{
chromosome.Sections[range1.Section] = temp1;
chromosome.Sections[range2.Section] = temp2;
}
if (!childConflicted || retryCount-- < 0)
{
//TODO: Remove this (only for debugging purpose)
chromosome.GeneratedRandoms.Add(range1.Section);
chromosome.GeneratedRandoms.Add(range1.FirstPosition);
chromosome.GeneratedRandoms.Add(range1.LastPosition);
chromosome.GeneratedRandoms.Add(range2.Section);
chromosome.GeneratedRandoms.Add(range2.FirstPosition);
chromosome.GeneratedRandoms.Add(range2.LastPosition);
break;
}
childConflicted = false;
}
if (childConflicted)
{
return(null);
}
CleanOutSections(chromosome);
return(chromosome);
}
/// <summary>
/// Returns a new position randomly choosen from the conflict-list
/// </summary>
/// <param name="chromosome"></param>
/// <returns></returns>
public GenePosition GetConflictedSectionAndPosition(SortedSubsetChromosome chromosome)
{
var conflicted = Random.GetInt(0, chromosome.ConflictList.Count);
var source = chromosome.ConflictList[conflicted];
return(source);
}
private int GetNumberOfGenesToChange(SortedSubsetChromosome chromosome)
{
int max = chromosome.TotalCount / chromosome.Sections.Length;
int min = Math.Min(chromosome.ConflictList.Count, max);
return(Random.GetInt(min, max));
}
/// <summary>
/// Returns the gene values from a chromosome section
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <param name="sectionIndex">The index of the section</param>
/// <param name="position">The position of the first gene to get</param>
/// <param name="count">The number of genes to get</param>
/// <returns>The array of gene values</returns>
public int[] GetGenes(SortedSubsetChromosome chromosome, int sectionIndex, int position, int count)
{
int[] result = new int[count];
Array.Copy(chromosome.Sections[sectionIndex], position, result, 0, count);
return(result);
}
private GenePosition GetTargetSection(SortedSubsetChromosome chromosome, int sectionToEliminate, int geneValue)
{
List <GenePosition> fitSections = new List <GenePosition>();
for (int s = 0; s < chromosome.Sections.Length; s++)
{
if (s != sectionToEliminate)
{
var position = FindNewGenePosition(chromosome.Sections[s], geneValue);
if (!ConflictDetectedWithLeftNeighbor(chromosome.Sections[s], position, geneValue) &&
!ConflictDetectedWithRightNeighbor(chromosome.Sections[s], position, geneValue))
{
fitSections.Add(new GenePosition(s, position));
}
}
}
if (fitSections.Count == 0)
{
return(null);
}
var randomIndex = Random.GetInt(0, fitSections.Count);
var chosenSection = fitSections[randomIndex];
return(chosenSection);
}
public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
if (chromosome.Sections.Length < 2)
{
return(null);
}
int retryCount = ParameterSet.GetInt(ParameterNames.FailedMutationRetryCount);
while (true)
{
var source = GetSourceSectionAndPosition(chromosome);
var section = chromosome.Sections[source.Section];
var position = source.Position;
var length = Random.GetInt(0, section.Length - source.Position);
var targetSectionIndex = Random.GetIntWithTabu(0, chromosome.Sections.Length, source.Section);
var targetSection = chromosome.Sections[targetSectionIndex];
while (position < source.Position + length)
{
var geneValue = section[position];
var targetPosition = FindNewGenePosition(targetSection, geneValue);
var insertable = CountInsertableGenes(chromosome, targetSectionIndex, targetPosition, section, position);
bool conflict = ConflictDetectedWithLeftNeighbor(targetSection, targetPosition, geneValue);
if (!conflict)
{
var lastGeneValue = section[position + insertable - 1];
conflict = ConflictDetectedWithRightNeighbor(targetSection, targetPosition, lastGeneValue);
}
if (conflict)
{
break;
}
InsertGenes(chromosome, targetSectionIndex, targetPosition, section, position, insertable);
position += insertable;
}
if (position > source.Position || retryCount-- < 0)
{
break;
}
}
CleanOutSections(chromosome);
return(chromosome);
}
/// <summary>
/// Make a (mostly random) decision on the using of the conflict list
/// </summary>
/// <param name="chromosome"></param>
/// <returns></returns>
public bool ConflictShouldBeEliminated(SortedSubsetChromosome chromosome)
{
if (chromosome.ConflictList.Count == 0)
{
return(false);
}
var reducingConflictPossibility = ParameterSet.GetValue(ParameterNames.ConflictReducingProbability);
var rnd = Random.GetDouble(0, 1);
return(rnd < reducingConflictPossibility);
}
private int GetSectionToEliminate(SortedSubsetChromosome chromosome)
{
var provider = new StochasticProvider <int>(this.Random);
for (int s = 0; s < chromosome.Sections.Length; s++)
{
var section = chromosome.Sections[s];
var probability = chromosome.TotalCount / (double)section.Length;
provider.Add(s, probability);
}
int chosen = provider.GetOne();
return(chosen);
}
/// <summary>
/// Returns the count of genes can be inserted to a given section and position inside it.
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <param name="sectionIndex">The index of the section</param>
/// <param name="insertPosition">The position inside the section</param>
/// <param name="genesToInsert">The gene array to insert</param>
/// <param name="firstGeneIndex">The first gene's index inside the gene array</param>
/// <returns>The possible count of the insertable genes</returns>
public int CountInsertableGenes(SortedSubsetChromosome chromosome, int sectionIndex,
int insertPosition, int[] genesToInsert, int firstGeneIndex)
{
var count = 0;
while ((firstGeneIndex + count < genesToInsert.Length) &&
((insertPosition > chromosome.Sections[sectionIndex].Length - 1) ||
(genesToInsert[firstGeneIndex + count] < chromosome.Sections[sectionIndex][insertPosition])
)
)
{
count++;
}
return(count);
}
/// <summary>
/// Delete given number of genes from a chromosome section and position inside it
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <param name="sectionIndex">The index of the section</param>
/// <param name="position">The position inside the section</param>
/// <param name="count">The number of genes to be deleted</param>
public void DeleteGenesFromSection(SortedSubsetChromosome chromosome, int sectionIndex, int position, int count)
{
int[] section = chromosome.Sections[sectionIndex];
int[] temp = new int[section.Length - count];
if (position > 0)
{
Array.Copy(section, 0, temp, 0, position);
}
if (position < section.Length - count + 1)
{
Array.Copy(section, position + count, temp, position, section.Length - position - count);
}
chromosome.Sections[sectionIndex] = temp;
}
/// <summary>
/// Returns a new random position
/// </summary>
/// <param name="chromosome"></param>
/// <returns></returns>
public GenePosition GetRandomSectionAndPosition(SortedSubsetChromosome chromosome)
{
var sectionLength = 0;
var sourceSectionIndex = 0;
while (sectionLength == 0)
{
sourceSectionIndex = Random.GetInt(0, chromosome.Sections.Length);
sectionLength = chromosome.Sections[sourceSectionIndex].Length;
}
var sourcePosition = Random.GetInt(0, chromosome.Sections[sourceSectionIndex].Length);
var source = new GenePosition(sourceSectionIndex, sourcePosition);
return(source);
}
/// <summary>
/// Deletes all the sections with length of 0
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <returns>True if at least one chromosome is eliminated</returns>
public bool CleanOutSections(SortedSubsetChromosome chromosome)
{
//TODO: simlpy move the sections?
int[][] sections = chromosome.Sections;
var sectionsToDeleteCount = 0;
foreach (var section in sections)
{
if (section.Length == 0)
{
sectionsToDeleteCount++;
}
}
if (sectionsToDeleteCount == 0)
{
return(false);
}
int[][] temp = new int[sections.Length - sectionsToDeleteCount][];
int sourceStart = 0;
int targetStart = 0;
for (int s = 0; s < sections.Length; s++)
{
if (sections[s].Length == 0)
{
if (sourceStart < s)
{
Array.Copy(sections, sourceStart, temp, targetStart, s - sourceStart);
targetStart += s - sourceStart;
}
sourceStart = s + 1;
}
}
if (sourceStart < sections.Length)
{
Array.Copy(sections, sourceStart, temp, targetStart, sections.Length - sourceStart);
}
chromosome.Sections = temp;
return(true);
}
/// <summary>
/// Delete one section completely from the chromosome
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <param name="sectionIndex">The index of the section to be deleted</param>
public void DeleteSection(SortedSubsetChromosome chromosome, int sectionIndex)
{
//TODO: simlpy move the sections?
int[][] sections = chromosome.Sections;
int[][] temp = new int[sections.Length - 1][];
if (sectionIndex > 0)
{
Array.Copy(sections, 0, temp, 0, sectionIndex);
}
if (sectionIndex < sections.Length)
{
Array.Copy(sections, sectionIndex + 1, temp, sectionIndex, sections.Length - sectionIndex - 1);
}
chromosome.Sections = temp;
}
public SortedSubsetChromosome IncrementNumberOfSections(SortedSubsetChromosome chromosome, LinkedList <int> sectionList)
{
int length = chromosome.Sections.Length;
var newSections = new int[length + 1][];
Array.Copy(chromosome.Sections, newSections, length);
newSections[length] = new int[sectionList.Count];
var node = sectionList.First;
for (int i = 0; i < sectionList.Count; i++)
{
newSections[length][i] = node.Value;
node = node.Next;
}
chromosome.Sections = newSections;
return(chromosome);
}
public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
var numberOfGenesToReplace = GetNumberOfGenesToChange(chromosome);
int retryCount = ParameterSet.GetInt(ParameterNames.FailedMutationRetryCount);
int replaced = 0;
var targetList = new LinkedList <int>();
for (int i = 0; i < numberOfGenesToReplace; i++)
{
var tryCount = retryCount;
while (true)
{
GenePosition source = GetSourceSectionAndPosition(chromosome);
var geneValue = chromosome.Sections[source.Section][source.Position];
var success = InsertGeneToLinkedList(targetList, geneValue);
if (success)
{
DeleteGenesFromSection(chromosome, source.Section, source.Position, 1);
replaced++;
}
if (success || tryCount-- < 0)
{
break;
}
}
}
IncrementNumberOfSections(chromosome, targetList);
CleanOutSections(chromosome);
return(chromosome);
}
public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
if (chromosome.Sections.Length < 2)
{
return(null);
}
var sectionToEliminate = GetSectionToEliminate(chromosome);
for (int g = chromosome.Sections[sectionToEliminate].Length - 1; g >= 0; g--)
{
var geneValue = chromosome.Sections[sectionToEliminate][g];
var target = GetTargetSection(chromosome, sectionToEliminate, geneValue);
if (target == null)
{
continue;
}
InsertGenes(chromosome, target.Section, target.Position, new int[] { geneValue }, 0, 1);
DeleteGenesFromSection(chromosome, sectionToEliminate, g, 1);
}
bool eliminated = CleanOutSections(chromosome);
//TODO: Delete this
//if (eliminated)
//{
// var yepp = true;
//}
return(chromosome);
}
/// <summary>
/// Insert one gene into a chromosome section and position inside it
/// </summary>
/// <param name="chromosome">The multi-section chromosome which the operator works within</param>
/// <param name="sectionIndex">The index of the section</param>
/// <param name="insertPosition">The position inside the section</param>
/// <param name="genesToInsert">The array of genes to insert</param>
public bool InsertGenes(SortedSubsetChromosome chromosome, int sectionIndex, int insertPosition, int[] genesToInsert, int firstGeneIndex, int count)
{
if (ConflictDetectedWithLeftNeighbor(chromosome.Sections[sectionIndex], insertPosition,
genesToInsert[firstGeneIndex]))
{
return(false);
}
if (ConflictDetectedWithRightNeighbor(chromosome.Sections[sectionIndex], insertPosition,
genesToInsert[firstGeneIndex + count - 1]))
{
return(false);
}
int[] section = chromosome.Sections[sectionIndex];
int[] temp = new int[section.Length + count];
if (insertPosition > 0)
{
Array.Copy(section, 0, temp, 0, insertPosition);
}
if (count > 0)
{
Array.Copy(genesToInsert, firstGeneIndex, temp, insertPosition, count);
}
if (insertPosition < section.Length)
{
Array.Copy(section, insertPosition, temp, insertPosition + count, section.Length - insertPosition);
}
chromosome.Sections[sectionIndex] = temp;
return(true);
}
public override SortedSubsetChromosome Mutate(SortedSubsetChromosome chromosome)
{
if (chromosome == null)
{
return(null);
}
if (chromosome.Sections.Length < 3)
{
return(null);
}
bool childConflicted = false;
int retryCount = ParameterSet.GetInt(ParameterNames.FailedMutationRetryCount);
while (true)
{
var firstRange = GetSourceRange(chromosome);
var firstSection = chromosome.Sections[firstRange.Section];
var firstGeneValue1 = firstSection[firstRange.FirstPosition];
var firstGeneValue2 = firstSection[firstRange.LastPosition - 1];
var secondSectionIndex = Random.GetIntWithTabu(0, chromosome.Sections.Length, firstRange.Section);
var secondSection = chromosome.Sections[secondSectionIndex];
var secondPosition1 = FindNewGenePosition(secondSection, firstGeneValue1);
var secondPosition2 = FindNewGenePosition(secondSection, firstGeneValue2);
var secondRange = new GeneRange(secondSectionIndex, secondPosition1, secondPosition2);
if (secondRange.Length == 0)
{
childConflicted = true;
}
if (!childConflicted)
{
var secondGeneValue1 = secondSection[secondRange.FirstPosition];
var secondGeneValue2 = secondSection[secondRange.LastPosition - 1];
var thirdSectionIndex = Random.GetIntWithTabu(0, chromosome.Sections.Length, firstRange.Section,
secondRange.Section);
var thirdSection = chromosome.Sections[thirdSectionIndex];
var thirdPosition1 = FindNewGenePosition(thirdSection, secondGeneValue1);
var thirdPosition2 = FindNewGenePosition(thirdSection, secondGeneValue2);
var thirdRange = new GeneRange(thirdSectionIndex, thirdPosition1, thirdPosition2);
var temp1 = MergeSections(firstSection, firstRange, secondSection, secondRange,
ref childConflicted);
var temp2 = MergeSections(secondSection, secondRange, thirdSection, thirdRange,
ref childConflicted);
var temp3 = MergeSections(thirdSection, thirdRange, firstSection, firstRange, ref childConflicted);
if (!childConflicted)
{
chromosome.Sections[firstRange.Section] = temp1;
chromosome.Sections[secondRange.Section] = temp2;
chromosome.Sections[thirdRange.Section] = temp3;
}
}
if (!childConflicted || retryCount-- < 0)
{
break;
}
childConflicted = false;
}
if (childConflicted)
{
return(null);
}
CleanOutSections(chromosome);
return(chromosome);
}
public override IList <IChromosome> Cross(IChromosome iparent0, IChromosome iparent1)
{
var children = new List <IChromosome>();
var parent1 = iparent0 as SortedSubsetChromosome;
var parent2 = iparent1 as SortedSubsetChromosome;
var sectionsCount = parent1.Sections.Length > parent2.Sections.Length
? parent1.Sections.Length
: parent2.Sections.Length;
var totalCount = parent1.TotalCount > parent2.TotalCount
? parent1.TotalCount
: parent2.TotalCount;
var child0 = new int[sectionsCount][];
var child1 = new int[sectionsCount][];
bool child0Conflicted = false;
bool child1Conflicted = false;
int retryCount = ParameterSet.GetInt(ParameterNames.FailedCrossoverRetryCount);
while (true)
{
var crossoverPosition = Random.GetInt(0, totalCount);
for (int sectionIndex = 0; sectionIndex < sectionsCount; sectionIndex++)
{
bool section0Exists = (parent1.Sections.Length > sectionIndex);
var section0 = section0Exists ? parent1.Sections[sectionIndex] : new int[0];
var position0 = section0Exists ? FindNewGenePosition(section0, crossoverPosition) : 0;
bool section1Exists = (parent2.Sections.Length > sectionIndex);
var section1 = section1Exists ? parent2.Sections[sectionIndex] : new int[0];
var position1 = section1Exists ? FindNewGenePosition(section1, crossoverPosition) : 0;
var child0Section = MergeSections(section0, position0, section1, position1, ref child0Conflicted);
child0[sectionIndex] = child0Section;
var child1Section = MergeSections(section1, position1, section0, position0, ref child1Conflicted);
child1[sectionIndex] = child1Section;
//TODO: Merge conflict lists
if (child0Conflicted && child1Conflicted)
{
break;
}
}
if (!child0Conflicted || !child1Conflicted)
{
////TODO: Delete this
//var conflictedPositions0 =
// child0Conflicted ? new List<GenePosition>() : SortedSubsetChromosomeValidator.SearchForConflict(child0);
//var conflictedPositions1 =
// child1Conflicted ? new List<GenePosition>() : SortedSubsetChromosomeValidator.SearchForConflict(child1);
//if (conflictedPositions0.Count > 0 || conflictedPositions1.Count > 0)
//{
// bool error = true; //For breakpoints
// throw new ApplicationException("Conflict between neighboring values! (Crossover: OnePointCrossover)");
//}
break;
}
if (retryCount-- < 0)
{
break;
}
child0 = new int[sectionsCount][];
child1 = new int[sectionsCount][];
child0Conflicted = false;
child1Conflicted = false;
}
if (!child0Conflicted)
{
var child0Chromosome = new SortedSubsetChromosome(child0);
CleanOutSections(child0Chromosome);
children.Add(child0Chromosome);
}
if (!child1Conflicted)
{
var child1Chromosome = new SortedSubsetChromosome(child1);
CleanOutSections(child1Chromosome);
children.Add(child1Chromosome);
}
return(children);
}
public int GetGeneValue(SortedSubsetChromosome chromosome, GenePosition genePosition)
{
return(chromosome.Sections[genePosition.Section][genePosition.Position]);
}
/// <summary>
/// Returns a new position from the conflict-list or randomly
/// </summary>
/// <param name="chromosome"></param>
/// <returns></returns>
public GenePosition GetSourceSectionAndPosition(SortedSubsetChromosome chromosome)
{
return(ConflictShouldBeEliminated(chromosome)
? GetConflictedSectionAndPosition(chromosome)
: GetRandomSectionAndPosition(chromosome));
}
