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 GetChild(Individ _parent, Curriculum _c)
{
Individ ResultingChild = (Individ)_parent.Clone();
for (int RanInensityIndex = 0; RanInensityIndex < Parameters.ShiftMutateIntensity;
RanInensityIndex++)
{
//Boolean preReq4 = BasicFunctions.checkPrerequisites(ResultingChild.Representation, _c);
int[] ShiftingSolution = this.getShiftingSolution(_c, ResultingChild);
int OriginePeriod = ShiftingSolution[0];
int CourseID = ShiftingSolution[1];
int DestinationPeriod = ShiftingSolution[2];
if (CourseID != 0)
{
ResultingChild.Representation[OriginePeriod].Remove(CourseID);
ResultingChild.Representation[DestinationPeriod].Add(CourseID);
ResultingChild.PeriodCreditLoad[OriginePeriod] -= _c.courses[CourseID - 1].credit;
ResultingChild.PeriodCreditLoad[DestinationPeriod] += _c.courses[CourseID - 1].credit;
ResultingChild.Evaluation = BasicFunctions.AssessFitnessMaximumLoad(ResultingChild);
//Boolean preReq5 = BasicFunctions.checkPrerequisites(ResultingChild.Representation, _c);
}
}
return(ResultingChild);
}
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 SwapCourses(int CurrentPeriod, int MinMaxCreditLoadPeriod,
Curriculum _c, Individ _individ)
{
Individ ResultingIndivid = (Individ)_individ.Clone();
int LeftPeriodIndex, RightPeriodIndex;
List <int> LeftPeriodSwapCandidates, RightPeriodSwapCandidates;
if (CurrentPeriod < MinMaxCreditLoadPeriod)
{
LeftPeriodIndex = CurrentPeriod;
RightPeriodIndex = MinMaxCreditLoadPeriod;
}
else
{
LeftPeriodIndex = MinMaxCreditLoadPeriod;
RightPeriodIndex = CurrentPeriod;
}
LeftPeriodSwapCandidates =
this.getLeftPeriodSwapCandidates(_c, ResultingIndivid.Representation,
LeftPeriodIndex, RightPeriodIndex);
RightPeriodSwapCandidates =
this.getRightPeriodSwapCandidates(_c, ResultingIndivid.Representation,
LeftPeriodIndex, RightPeriodIndex);
if (LeftPeriodSwapCandidates.Count > 0 && RightPeriodSwapCandidates.Count > 0)
{
List <int> RandomLeftList = BasicFunctions.getRandomCourseList(LeftPeriodSwapCandidates);
List <int> RandomRightList = BasicFunctions.getRandomCourseList(RightPeriodSwapCandidates);
for (int IL = 0; IL < RandomLeftList.Count; IL++)
{
int LeftListCourseID = RandomLeftList[IL];
for (int IR = 0; IR < RandomRightList.Count; IR++)
{
int RightListCourseID = RandomRightList[IR];
int LeftPeriodForeseenCreditLoad = ResultingIndivid.PeriodCreditLoad[LeftPeriodIndex] +
_c.courses[RightListCourseID - 1].credit - _c.courses[LeftListCourseID - 1].credit;
int RightPeriodForeseenCreditLoad = ResultingIndivid.PeriodCreditLoad[RightPeriodIndex] +
_c.courses[LeftListCourseID - 1].credit - _c.courses[RightListCourseID - 1].credit;
bool LeftPeriodCreditLoadFeasible = LeftPeriodForeseenCreditLoad >= _c.minCredits && LeftPeriodForeseenCreditLoad <= _c.maxCredits;
bool RightPeriodCreditLoadFeasible = RightPeriodForeseenCreditLoad >= _c.minCredits && RightPeriodForeseenCreditLoad <= _c.maxCredits;
if (LeftPeriodCreditLoadFeasible && RightPeriodCreditLoadFeasible)
{
ResultingIndivid.Representation[LeftPeriodIndex].Remove(LeftListCourseID);
ResultingIndivid.Representation[LeftPeriodIndex].Add(RightListCourseID);
ResultingIndivid.Representation[RightPeriodIndex].Remove(RightListCourseID);
ResultingIndivid.Representation[RightPeriodIndex].Add(LeftListCourseID);
ResultingIndivid.PeriodCreditLoad[LeftPeriodIndex] +=
(_c.courses[RightListCourseID - 1].credit -
_c.courses[LeftListCourseID - 1].credit);
ResultingIndivid.PeriodCreditLoad[RightPeriodIndex] +=
(_c.courses[LeftListCourseID - 1].credit -
_c.courses[RightListCourseID - 1].credit);
goto ReturnIndivid;
}
}
}
}
ReturnIndivid:
ResultingIndivid.Evaluation = BasicFunctions.AssessFitnessMaximumLoad(ResultingIndivid);
return(ResultingIndivid);
}
