public Individ GetChild(Individ _parent, Curriculum _c)
{
Individ ResultingChild = (Individ)_parent.Clone();
int PeriodA, PeriodB;
for (int RanInensityIndex = 0; RanInensityIndex < Parameters.SwapMutateIntensity;
RanInensityIndex++)
{
PeriodA = BasicFunctions.randomGenerator.Next(0, _c.noPeriods);
PeriodB = this.getRandomPeriod(PeriodA, _c.noPeriods);
Boolean preReq = BasicFunctions.checkPrerequisites(_parent.Representation, _c);
Boolean ChecMinMaxCredits = BasicFunctions.checkMinMaxCredit(_parent.PeriodCreditLoad, _c.maxCredits, _c.minCredits);
Boolean ChecMinMaxCourses = BasicFunctions.checkMinMaxCourse(_parent.Representation, _c.maxCourses, _c.minCourses);
Boolean CheckEvaluation = BasicFunctions.checkFitnessMaximumLoad(_parent.Representation, _c, _parent.Evaluation);
//Console.WriteLine(BasicFunctions.getSolutionDetails(_parent));
ResultingChild = this.SwapCourses(PeriodA, PeriodB, _c, _parent);
//Console.WriteLine(BasicFunctions.getSolutionDetails(ResultingChild));
Boolean preReq2 = BasicFunctions.checkPrerequisites(ResultingChild.Representation, _c);
Boolean ChecMinMaxCredits2 = BasicFunctions.checkMinMaxCredit(ResultingChild.PeriodCreditLoad, _c.maxCredits, _c.minCredits);
Boolean ChecMinMaxCourses2 = BasicFunctions.checkMinMaxCourse(ResultingChild.Representation, _c.maxCourses, _c.minCourses);
Boolean CheckEvaluation2 = BasicFunctions.checkFitnessMaximumLoad(ResultingChild.Representation, _c, ResultingChild.Evaluation);
}
return(ResultingChild);
}
public Individ getRandomIndivid(Curriculum _c)
{
Individ RandomIndivid = new Individ(_c.noPeriods);
// Step 1: Consider Prerequisits and MinMaxCourses constraints
int[] InitialNoCoursePerPeriod = this.getInitialNoCoursePerPeriod(_c.courses.Count, _c.noPeriods);
int CourseID, PeriodStartIndex = 0;
for (int CourseIndex = 0; CourseIndex < _c.courses.Count; CourseIndex++)
{
CourseID = _c.courses[CourseIndex].ID;
List <int> RequiredCourses = _c.courses[CourseIndex].RequiredCourses;
for (int PeriodIndex = PeriodStartIndex; PeriodIndex < _c.noPeriods; PeriodIndex++)
{
if (RandomIndivid.Representation[PeriodIndex].Count < InitialNoCoursePerPeriod[PeriodIndex])
{
if (
RandomIndivid.PeriodCreditLoad[PeriodIndex] + _c.courses[CourseIndex].credit <= _c.maxCredits &&
!ContainsGroup(RandomIndivid.Representation[PeriodIndex], RequiredCourses)
)
{
RandomIndivid.Representation[PeriodIndex].Add(CourseID);
RandomIndivid.PeriodCreditLoad[PeriodIndex] += _c.courses[CourseIndex].credit;
break;
}
}
else
{
PeriodStartIndex++;
}
}
}
//Step 2 :Incorporate randomness
int PeriodA, PeriodB;
for (int RanInensityIndex = 0; RanInensityIndex < Parameters.InitialSolutionRandomnessIntensity;
RanInensityIndex++)
{
PeriodA = BasicFunctions.randomGenerator.Next(0, _c.noPeriods);
PeriodB = this.getRandomPeriod(PeriodA, _c.noPeriods);
RandomIndivid = this.SwapCourses(PeriodA, PeriodB, _c, RandomIndivid);
}
//Step 3 :Consider MinMaxCredits constraint
Boolean MinMaxCreditsConstraintFulfilled = false;
while (!MinMaxCreditsConstraintFulfilled)
{
int PeriodCount = 0, RandomPeriod;
for (int CurrentPeriod = 0; CurrentPeriod < _c.noPeriods; CurrentPeriod++)
{
if (RandomIndivid.PeriodCreditLoad[CurrentPeriod] > _c.maxCredits ||
RandomIndivid.PeriodCreditLoad[CurrentPeriod] < _c.minCredits)
{
RandomPeriod = this.getRandomPeriod(CurrentPeriod, _c.noPeriods);
RandomIndivid = this.SwapCourses(CurrentPeriod, RandomPeriod, _c, RandomIndivid);
break;
}
PeriodCount++;
}
if (PeriodCount == _c.noPeriods)
{
MinMaxCreditsConstraintFulfilled = true;
}
}
RandomIndivid.Evaluation = BasicFunctions.AssessFitnessMaximumLoad(RandomIndivid);
Boolean preReq = BasicFunctions.checkPrerequisites(RandomIndivid.Representation, _c);
Boolean ChecMinMaxCredits = BasicFunctions.checkMinMaxCredit(RandomIndivid.PeriodCreditLoad, _c.maxCredits, _c.minCredits);
Boolean ChecMinMaxCourses = BasicFunctions.checkMinMaxCourse(RandomIndivid.Representation, _c.maxCourses, _c.minCourses);
Boolean CheckEvaluation = BasicFunctions.checkFitnessMaximumLoad(RandomIndivid.Representation, _c, RandomIndivid.Evaluation);
return(RandomIndivid);
}
public Individ Apply(Curriculum objCurriculum)
{
Individ Best = new Individ(objCurriculum.noPeriods);
Individ[] P = Enumerable.Repeat(
new Individ(objCurriculum.noPeriods), Parameters.popSize).ToArray();
Individ[] Q = Enumerable.Repeat(
new Individ(objCurriculum.noPeriods), Parameters.popSize).ToArray();
for (int i = 0; i < Parameters.popSize; i++)
{
Individ currentIndivid = getRandomIndivid(objCurriculum);
//Individ currentIndivid = iah.getRandomIndivid(objCurriculum);
//Individ currentIndivid = ifa.getRandomIndivid(objCurriculum);
Boolean preReq = BasicFunctions.checkPrerequisites(currentIndivid.Representation, objCurriculum);
Boolean ChecMinMaxCredits = BasicFunctions.checkMinMaxCredit(currentIndivid.PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses = BasicFunctions.checkMinMaxCourse(currentIndivid.Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation = BasicFunctions.checkFitnessMaximumLoad(currentIndivid.Representation, objCurriculum, currentIndivid.Evaluation);
P[i] = (Individ)currentIndivid.Clone();
}
Best = (Individ)P[0].Clone();
int CurrentGeneration = 1;
do
{
for (int i = 0; i < Parameters.popSize; i++)
{
Boolean preReq = BasicFunctions.checkPrerequisites(P[i].Representation, objCurriculum);
Boolean ChecMinMaxCredits = BasicFunctions.checkMinMaxCredit(P[i].PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses = BasicFunctions.checkMinMaxCourse(P[i].Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation = BasicFunctions.checkFitnessMaximumLoad(P[i].Representation, objCurriculum, P[i].Evaluation);
if (P[i].Evaluation < Best.Evaluation)
{
Best = (Individ)P[i].Clone();;
Console.WriteLine("Current generation: " + CurrentGeneration);
Console.WriteLine(BasicFunctions.getSolutionDetails(Best));
}
}
for (int i = 0; i < Parameters.popSize; i += 2)
{
Individ ParentA = BasicFunctions.GetBestParent(P);
Individ ParentB = BasicFunctions.GetBestParent(P);
Individ childA, childB;
if (SwapMutationOn)
{
childA = objSwapMutate.GetChild(ParentA, objCurriculum);
childB = objSwapMutate.GetChild(ParentB, objCurriculum);
}
else
{
Boolean preReq = BasicFunctions.checkPrerequisites(ParentA.Representation, objCurriculum);
Boolean ChecMinMaxCredits = BasicFunctions.checkMinMaxCredit(ParentA.PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses = BasicFunctions.checkMinMaxCourse(ParentA.Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation = BasicFunctions.checkFitnessMaximumLoad(ParentA.Representation, objCurriculum, ParentA.Evaluation);
childA = objShiftMutate.GetChild(ParentA, objCurriculum);
Boolean preReq2 = BasicFunctions.checkPrerequisites(childA.Representation, objCurriculum);
Boolean ChecMinMaxCredits2 = BasicFunctions.checkMinMaxCredit(childA.PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses2 = BasicFunctions.checkMinMaxCourse(childA.Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation2 = BasicFunctions.checkFitnessMaximumLoad(childA.Representation, objCurriculum, childA.Evaluation);
Boolean preReq3 = BasicFunctions.checkPrerequisites(ParentB.Representation, objCurriculum);
Boolean ChecMinMaxCredits3 = BasicFunctions.checkMinMaxCredit(ParentB.PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses3 = BasicFunctions.checkMinMaxCourse(ParentB.Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation3 = BasicFunctions.checkFitnessMaximumLoad(ParentB.Representation, objCurriculum, ParentB.Evaluation);
childB = objShiftMutate.GetChild(ParentB, objCurriculum);
Boolean preReq4 = BasicFunctions.checkPrerequisites(childB.Representation, objCurriculum);
Boolean ChecMinMaxCredits4 = BasicFunctions.checkMinMaxCredit(childB.PeriodCreditLoad, objCurriculum.maxCredits, objCurriculum.minCredits);
Boolean ChecMinMaxCourses4 = BasicFunctions.checkMinMaxCourse(childB.Representation, objCurriculum.maxCourses, objCurriculum.minCourses);
Boolean CheckEvaluation4 = BasicFunctions.checkFitnessMaximumLoad(childB.Representation, objCurriculum, childB.Evaluation);
}
Q[i] = (Individ)childA.Clone();
Q[i + 1] = (Individ)childB.Clone();
}
P = (Individ[])Q.Clone();
CurrentGeneration++;
if (CurrentGeneration % (Parameters.MutationAlternationFrequency * Parameters.MaxGeneration) == 0)
{
SwapMutationOn = !SwapMutationOn;
}
}while (CurrentGeneration <= Parameters.MaxGeneration);
MessageBox.Show("Best solution details:\n" + BasicFunctions.getSolutionDetails(Best));
return(Best);
}
public Individ GetChild2(Individ parentA, Curriculum c)
{
//step 1: construct list of period loads
int[] tempPeriodList = new int[] { 0, 1, 2, 3, 4, 5, 6, 7 };
int[] tempPeriodListCredits = (int[])parentA.PeriodCreditLoad.Clone();
for (int i = 0; i < tempPeriodListCredits.Length - 1; i++)
{
for (int j = i + 1; j < tempPeriodListCredits.Length; j++)
{
if (tempPeriodListCredits[i] < tempPeriodListCredits[j])
{
int temp = tempPeriodListCredits[i];
tempPeriodListCredits[i] = tempPeriodListCredits[j];
tempPeriodListCredits[j] = temp;
temp = tempPeriodList[i];
tempPeriodList[i] = tempPeriodList[j];
tempPeriodList[j] = temp;
}
}
}
//start swaping by most and least loaded period
int left = 0, right = tempPeriodList.Length - 1;
List <int> candidatePeriod1 = parentA.Representation[tempPeriodList[left]];
List <int> candidatePeriod2 = parentA.Representation[tempPeriodList[right]];
for (int i = 0; i < candidatePeriod1.Count; i++)
{
//krahasimi me mesataren e period load
if (parentA.PeriodCreditLoad[tempPeriodList[right]] > parentA.PeriodCreditLoad[tempPeriodList[left]])
{
break;
}
int candidateCourse = candidatePeriod1[i];
parentA.Representation[tempPeriodList[left]].Remove(candidateCourse);
parentA.Representation[tempPeriodList[right]].Add(candidateCourse);
if (!BasicFunctions.checkPrerequisites(parentA.Representation, c) || !BasicFunctions.checkMinMaxCourse(parentA.Representation, c.maxCourses, c.minCourses) ||
!BasicFunctions.checkMinMaxCredit(parentA.PeriodCreditLoad, c.maxCredits, c.minCredits))
{
parentA.Representation[tempPeriodList[right]].Remove(candidateCourse);
parentA.Representation[tempPeriodList[left]].Add(candidateCourse);
}
//update periodcreditload
int s = 0;
for (int k = 0; k < parentA.Representation[tempPeriodList[right]].Count; k++)
{
s += c.courses[parentA.Representation[tempPeriodList[right]][k] - 1].credit;
}
parentA.PeriodCreditLoad[tempPeriodList[right]] = s;
s = 0;
for (int k = 0; k < parentA.Representation[tempPeriodList[left]].Count; k++)
{
s += c.courses[parentA.Representation[tempPeriodList[left]][k] - 1].credit;
}
parentA.PeriodCreditLoad[tempPeriodList[left]] = s;
}
return(parentA);
}
