public static List <Course> Reduce(CreditDeterminer creditDeterminer, List <CourseInformation> courseInfoLst, int currentTermNumber)
{
int passedUnitsNumber = 0;
//create a curriculum object with specific credit
MainCurriculum curriculum = new MainCurriculum(MainCurriculum.CreateStudentCredit(creditDeterminer.Level1, creditDeterminer.Level2));
//update curriculm's courses properties considering student history information
for (int i = 0; i < courseInfoLst.Count; i++)
{
var currentCourseInfo = courseInfoLst[i];
var currentCourse = curriculum.Courses[i];
if (currentCourseInfo.Id != currentCourse.Id)
{
throw new ArgumentException();
}
currentCourse.CodeInDesUni = currentCourseInfo.CodeInDesUni;
currentCourse.CorrespondingTitleInDesUni = currentCourseInfo.CorrespondingTitleInDesUni;
if (currentCourseInfo.IsPassed)
{
currentCourse.IsPassed = true;
passedUnitsNumber += currentCourse.Units;
}
else if (currentCourseInfo.NumberOfFailed > 1)
{
currentCourse.NumberOfFailed = 2;
}
}
return(Reduce(curriculum, currentTermNumber, passedUnitsNumber));
}
//1
//Layers.ReductionSteps.ReductionStep1.TryReduce(DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CreditDeterminerSavedName, DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CourseInformationSavedName, termNumberNow,out lst)
/// <summary>
///
/// </summary>
/// <param name="curriculum">باید خصوصیات آن با توجه به credit و CourseInfo ذخیره شده ست شده باشد </param>
/// <param name="currentTermNumber"></param>
/// <returns></returns>
public static List <Course> Reduce(MainCurriculum curriculum, int currentTermNumber, int cntPassedUnits)
{
List <SatelliteInformation> satList = curriculum.CreateNewSatelliteInformationList();
PopulateSatelliteInformation(curriculum, satList);
return(ReduceStep1Helper(curriculum, satList, cntPassedUnits, currentTermNumber));
}
/// <summary>
///
/// </summary>
/// <param name="takenCoursesArray"></param>
/// <param name="curriculum">!important :=> updated or not</param>
/// <returns></returns>
public static bool IsValidState(MainCurriculum curriculum, List <int> takenCoursesId)
{
//اگر در یک ترم بیش از یک معارف خواست بگیرد مجاز نیست
//اگر در ترم کارآموزی خواست بردارد حداکثر تا 6 واحد مجاز است
bool hasKarAmoozi = false;
int numberOfUnits = 0;
int numberOfMaaref = 0;
for (int i = 0; i < takenCoursesId.Count; i++)
{
numberOfUnits += curriculum.Courses[takenCoursesId[i]].Units;
if (takenCoursesId[i] <= 15)//assume :=> i >=0
{
numberOfMaaref++;
if (numberOfMaaref > 1)
{
return(false);
}
}
if (takenCoursesId[i] == 59 || takenCoursesId[i] == 66 || takenCoursesId[i] == 75 || takenCoursesId[i] == 83)
{
hasKarAmoozi = true;
}
if (hasKarAmoozi && numberOfUnits > 6)
{
return(false);
}
}
return(true);
}
private void CreateCourseInformationArrayAndFillItWithAppropriateData(out CourseInformation[] cfs)
{
try
{
MainCurriculum curriculum = new MainCurriculum();
cfs = new CourseInformation[curriculum.Courses.Count];
for (int i = 0; i < cfs.Length; i++)
{
var item = curriculum.Courses[i];
CourseInformation cf = new CourseInformation
{
Id = item.Id,
Title = item.Title,
CorrespondingTitleInDesUni = item.CorrespondingTitleInDesUni,
CodeInDesUni = item.CodeInDesUni,
IsPassed = item.IsPassed,
NumberOfFailed = item.NumberOfFailed,
};
cfs[i] = cf;
}
}
catch
{
cfs = null;
}
}
/// <summary>
/// all rules
/// </summary>
/// <param name="curriculum">updated curriculm provided by StudentHistoryServiceProvider.CreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion() must be passed</param>
/// <param name="takenCoursesId">id's of courses which you want to take and after it you want to know :=> curriculum is in valid state or not?</param>
/// <returns></returns>
public static bool IsValidState(MainCurriculum curriculum, List <int> takenCoursesId)
{
//secondary rules
bool o = SecondaryRulesStateValidator.IsValidState(curriculum, takenCoursesId);
if (!o)
{
return(false);
}
//basic rules
return(BasicRulesStateValidator.IsValidState(curriculum, takenCoursesId));
}
private static bool PrerequisitesAndRequisitesRegarded(MainCurriculum curriculum, bool[] takenCoursesArray, List <int> takenCoursesId)
{
bool succ = true;
for (int i = 0; i < takenCoursesId.Count; i++)
{
succ = PrerequisitesAndRequisitesRegardedHelper(curriculum.Courses[takenCoursesId[i]], curriculum, takenCoursesArray);
if (!succ)
{
break;
}
}
return(succ);
}
private static bool PrerequisitesAndRequisitesRegardedHelper(Course course, MainCurriculum curriculum, bool[] takenCoursesArray)
{
bool succ = true;
succ = PrerequisitesAndRequisitesRegardedRequisitesHelper(course, curriculum, takenCoursesArray);
if (!succ)
{
return(false);
}
succ = PrerequisitesAndRequisitesRegardedPreRequisitesHelper(course, curriculum, takenCoursesArray);
return(succ);
}
private static List <Course> ReduceStep1Helper(MainCurriculum curriculum, List <SatelliteInformation> satList, int cntPassedUnits, int currentTermNumber)
{
bool[] visited = new bool[curriculum.Courses.Count];
bool[] achivable = new bool[visited.Length];
List <Course> lst = new List <Course>();
curriculum.Courses.ForEach(c =>
{
if (Acheivable(visited, achivable, curriculum, satList, c, cntPassedUnits, currentTermNumber))
{
lst.Add(c);
}
});
return(lst);
}
private static bool RecursiveCourseAcheivableCheck(MainCurriculum curriculum, List <SatelliteInformation> satList, Course c)
{
var ccLst = c.CourseCategories;
bool succ = false;
for (int i = 0; i < ccLst.Count; i++)
{
var cc = ccLst[i];
if (RecursiveCourseAcheivableCheckHelper(curriculum, satList, c, cc))
{
succ = true;
break;
}
}
return(succ);
}
public static MainCurriculum CreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion(string creditFileName, string courseInforamtionFileName)
{
CreditDeterminer creditDeterminer;
FileServiceProvider.DeserializeFromXmlFile(creditFileName, out creditDeterminer);
List <CourseInformation> courseInfoLst = null;
FileServiceProvider.DeserializeFromXmlFile(courseInforamtionFileName, out courseInfoLst);
//create a curriculum object with specific credit
MainCurriculum curriculum = new MainCurriculum(MainCurriculum.CreateStudentCredit(creditDeterminer.Level1, creditDeterminer.Level2));
//update curriculm's courses properties considering student history information
for (int i = 0; i < courseInfoLst.Count; i++)
{
var currentCourseInfo = courseInfoLst[i];
var currentCourse = curriculum.Courses[i];
if (currentCourseInfo.Id != currentCourse.Id)
{
throw new ArgumentException();
}
currentCourse.CodeInDesUni = currentCourseInfo.CodeInDesUni;
currentCourse.CorrespondingTitleInDesUni = currentCourseInfo.CorrespondingTitleInDesUni;
if (currentCourseInfo.IsPassed)
{
currentCourse.IsPassed = true;
}
else if (currentCourseInfo.NumberOfFailed > 1)
{
currentCourse.NumberOfFailed = 2;
}
}
return(curriculum);
}
/// <summary>
///
/// </summary>
/// <param name="curriculum">updated curriculm provided by StudentHistoryServiceProvider.CreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion() must be passed</param>
/// <param name="takenCoursesId">id's of courses which you want to take and after it you want to know :=> curriculum is in valid state or not ? </param>
/// <returns></returns>
public static bool IsValidState(MainCurriculum curriculum, List <int> takenCoursesId)
{
bool[] takenCoursesArray = new bool[curriculum.Courses.Count];
takenCoursesId.ForEach(t => takenCoursesArray[t] = true);
//------------------------------------------------------------------
bool o = PrerequisitesAndRequisitesRegarded(curriculum, takenCoursesArray, takenCoursesId);
if (o == false)
{
return(false);
}
//------------------------------------------------------------------
var satList = curriculum.CreateNewSatelliteInformationList();
PopulateSatelliteInformationHelper(curriculum.Root, satList, curriculum, takenCoursesArray);
return(IsValidState(curriculum, satList));
}
public void Run(double[] courseScore, List <OfferedCourse> whiteCourses, List <OfferedCourse> greenCourses, int minUnits, int maxUnits, int greenCoursesUnits, double whiteCoursesTotalScore, MainCurriculum mainCurriculum, List <Box> GreenCoursesBoxes, bool examCollideCheck, AlgorithmTopWeeklyProgramManager ChoosedWeeklyProgram, int timeout)
{
bool x = false;
Task.Run(() =>
{
Thread.Sleep(timeout);
x = true;
});
List <int> takenCoursesId = new List <int>();
while (true)
{
if (x)
{
return;
}
while (true)
{
if (x)
{
return;
}
do
{
if (x)
{
return;
}
Selected = new bool[whiteCourses.Count];
Score = 0;
CurrentSelectedUnits = 0;
takenCoursesId.Clear();
//init and assigning values to Selected array
for (int i = 0; i < Selected.Length; i++)
{
var offeredCourse = whiteCourses[i];
var course = whiteCourses[i].Course;
var pc = random.Next(100);
if (CurrentSelectedUnits + course.Units + greenCoursesUnits > maxUnits)
{
continue;
}
if (pc <= courseScore[course.Id] * 100.0 / whiteCoursesTotalScore)
{
Selected[i] = true;
CurrentSelectedUnits += course.Units;
takenCoursesId.Add(course.Id);
}
}
if (minUnits > CurrentSelectedUnits + greenCoursesUnits)
{
//no valid
}
}while (minUnits > CurrentSelectedUnits + greenCoursesUnits);
greenCourses.ForEach(gc => takenCoursesId.Insert(0, gc.Course.Id));
//two step validation
bool o = MainCurriculumSateValidator.IsValidState(mainCurriculum, takenCoursesId);
if (o)
{
break;
}
}
List <Box> boxes = new List <Box>();
GreenCoursesBoxes.ForEach(b => boxes.Add(b));
for (int i = 0; i < Selected.Length; i++)
{
if (Selected[i])
{
Box b = ReductionStep2ServiceProvider.CreateBoxForOfferedCourse(whiteCourses[i]);
boxes.Add(b);
}
}
List <Box> res = ReductionStep2ServiceProvider.Validate(boxes, examCollideCheck);
if (res != null)
{
//break;
ChoosedWeeklyProgram.AddUpdateRangeData(res[0].Rows);
}
}
}//end method Run
public static bool TryCreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion(string creditFileName, string courseInforamtionFileName, out MainCurriculum curriculum)
{
bool succ;
try
{
curriculum = CreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion(creditFileName, courseInforamtionFileName);
succ = true;
}
catch
{
curriculum = null;
succ = false;
}
return(succ);
}
public async Task RunAfterCreatedAsync()
{
try
{
await Task.Run(async () =>
{
await Dispatcher.InvokeAsync(() =>
{
InitializeComponent();
});
//settings
if (Properties.Settings.Default.CurrentTermNumber > 0)
termNumber = Properties.Settings.Default.CurrentTermNumber;
gender = Properties.Settings.Default.Gender == 'm' ? Tataiee.Harif.Infrastructures.GeneralEnums.Gender.MALE : Tataiee.Harif.Infrastructures.GeneralEnums.Gender.FEMALE;
if (Properties.Settings.Default.MinUnits > 0)
minUnits = Properties.Settings.Default.MinUnits;
if (Properties.Settings.Default.MinUnits <= Properties.Settings.Default.MaxUnits && Properties.Settings.Default.MaxUnits > 0)
maxUnits = Properties.Settings.Default.MaxUnits;
if (Properties.Settings.Default.TimeoutForReductionStep2ms >= 120)
timeoutMs = Properties.Settings.Default.TimeoutForReductionStep2ms;
if (Properties.Settings.Default.MaxNumberOfSuggestedWeeklyProgram >= 1 && Properties.Settings.Default.MaxNumberOfSuggestedWeeklyProgram <= 50)
maxCntSuggestion = Properties.Settings.Default.MaxNumberOfSuggestedWeeklyProgram;
capacityFiltering = Properties.Settings.Default.CapacityFiltering;
exampCollideChecking = Properties.Settings.Default.ExamCollideChecking;
//end settings
mainCurriculum = StudentHistoryServiceProvider.CreateNewCurriculmWithSpecificCreditAndFilledBySpecificCourseInforamtion(DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CreditDeterminerSavedName, DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CourseInformationSavedName);
int CODE_LEN = 7;
//load offered course row in memory
FileServiceProvider.DeserializeFromXmlFile(DirectoryManager.GoalVersionOfferedCoursesRowDirectory + DirectoryManager.GoalVersionOfferedCoursesRowSavedName, out List<GoalVersionOfferedCoursesRow> goalVersionOfferedCourseRows);
//perform reduction step 1 and get courses list after reduced
var coursesListAfterReductionStep1 = ReductionStep1.Reduce(DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CreditDeterminerSavedName, DirectoryManager.EssentialInforamtion1Directory + DirectoryManager.CourseInformationSavedName
, termNumber);
//assign offeredCourseRows to the output of ReductionStep2 courses List
if (capacityFiltering)
{
goalVersionOfferedCourseRows = ReductionStep2.Reduce(coursesListAfterReductionStep1, goalVersionOfferedCourseRows, gender)
.Where(r => r.Capacity - r.Registered > 0).ToList();
}
else
{
goalVersionOfferedCourseRows = ReductionStep2.Reduce(coursesListAfterReductionStep1, goalVersionOfferedCourseRows, gender);
}
CODE_LEN = coursesListAfterReductionStep1[0].CodeInDesUni.Length;
//again group reduced offered course rows
var coursesGroups = (from c in goalVersionOfferedCourseRows
group c by c.Id.Substring(0, CODE_LEN)).ToList();
//--------
//we can add another reduction step to reduce more if possible but not now.
//---------
//fill main offeredCourses and offeredCourseRows lists
int i = 0;
int j = 0;
foreach (var course in coursesGroups)
{
var c = coursesListAfterReductionStep1.FirstOrDefault(c1 => c1.CodeInDesUni == course.Key);
if (c != null)
{
OfferedCourse oc = new OfferedCourse(c, i++, ReductionStep2ColorStatus.WHITE);
foreach (var row in course)
{
OfferedCourseRow ocr = new OfferedCourseRow(row, ReductionStep2ColorStatus.WHITE, j++, oc);
oc.OfferedCourseRows.Add(ocr);
cards.Add(null);
offeredCourseRows.Add(ocr);
}
offeredCourses.Add(oc);
}
}
if (Properties.Settings.Default.ReductionStep2MustBeLoad)
{
FileServiceProvider.DeserializeFromXmlFile(DirectoryManager.ReductionStep2SavedStatus + DirectoryManager.SaveColorOfferedCourses, out List<SaveColorObjectModel> saveColorOfferedCourses);
FileServiceProvider.DeserializeFromXmlFile(DirectoryManager.ReductionStep2SavedStatus + DirectoryManager.SaveColorOfferedCourseRows, out List<SaveColorObjectModel> saveColorOfferedCourseRows);
saveColorOfferedCourses.ForEach(scoc =>
{
offeredCourses[scoc.CorrespondingIdInSourceList].Color = scoc.Color;
});
saveColorOfferedCourseRows.ForEach(scocr =>
{
offeredCourseRows[scocr.CorrespondingIdInSourceList].Color = scocr.Color;
});
}
//create and fill courses navigation buttons in the right side
await Dispatcher.InvokeAsync(() =>
{
stackPanelRightSide.Children.Clear();
Button button1 = null;
for (int m = 0; m < offeredCourses.Count; m++)
{
Badged badged = new Badged
{
Badge = offeredCourses[m].OfferedCourseCode,
Margin = new Thickness(5),
Name = "bdg" + offeredCourses[m].CourseId
};
Button button = new Button
{
Content = new TextBlock()
{
Text = offeredCourses[m].OfferedCourseName,
TextAlignment = TextAlignment.Center,
TextWrapping = TextWrapping.Wrap
},
Name = "btn" + m.ToString(),
Width = 250,
Height = Double.NaN,
Padding = new Thickness(5),
Background = Brushes.Transparent
};
button.Click += btnCourseNavigation_Click;
badged.Content = button;
if (m == 0)
{
button1 = button;
}
stackPanelRightSide.Children.Add(badged);
}
selectedButton = button1;
allowUserInteraction = true;
btnCourseNavigation_Click(button1, null);
});
});
}
catch
{
}
}
// <param name="mainCurriculum">updated curriculum</param>
public void Run(List <OfferedCourse> inputs, MainCurriculum mainCurriculum, int minUnitsRequired, int maxUnitsRequired, bool examCollideCheck, int timeout, AnimateStatusObjectModel model)
{
ChoosedWeeklyProgram.Clear();
double[] courseScore = new double[mainCurriculum.Courses.Count];
double numberOfGreenUnits = 0;
List <OfferedCourse> greenCourses = new List <OfferedCourse>();
List <OfferedCourse> whiteCourses = new List <OfferedCourse>();//white courses that have at least one white row
int greenUnits = 0;
for (int i = 0; i < inputs.Count; i++)
{
var offeredCourse = inputs[i];
if (offeredCourse.Color == ReductionStep2ColorStatus.Green)
{
greenCourses.Add(offeredCourse);
greenUnits += offeredCourse.Course.Units;
}
else if (offeredCourse.Color == ReductionStep2ColorStatus.WHITE)
{
for (int r = 0; r < offeredCourse.OfferedCourseRows.Count; r++)
{
var offeredCourseRow = offeredCourse.OfferedCourseRows[r];
if (offeredCourseRow.Color == ReductionStep2ColorStatus.WHITE)
{
whiteCourses.Add(offeredCourse);
break;
}
}
}
var course = offeredCourse.Course;
courseScore[course.Id] += (course.Units * 2 - 1) * 1;
for (int c = 0; c < course.PrerequisiteCourses.Count; c++)
{
var preCourse = course.PrerequisiteCourses[c];
if (!preCourse.IsPassed && preCourse.IsAvailable())
{
if (preCourse.NumberOfFailed > 1)
{
courseScore[preCourse.Id] += (course.Units * 2 - 1) * 0.20;
}
else
{
courseScore[preCourse.Id] += (course.Units * 2 - 1) * 0.25;
}
}
}
for (int c = 0; c < course.RequisiteCourses.Count; c++)
{
var reqCourse = course.RequisiteCourses[c];
if (!reqCourse.IsPassed && reqCourse.IsAvailable())
{
courseScore[reqCourse.Id] += (course.Units * 2 - 1) * 0.20;
}
}
}
double totalScore = 0;
whiteCourses.ForEach(i =>
{
totalScore += courseScore[i.Course.Id];
});
List <Box> greenCoursesBoxes = new List <Box>();
greenCourses.ForEach(gc =>
{
numberOfGreenUnits += gc.Course.Units;
Box b = ReductionStep2ServiceProvider.CreateBoxForOfferedCourse(gc);
greenCoursesBoxes.Add(b);
});
if (greenCoursesBoxes.Count > 0)
{
List <Box> res = ReductionStep2ServiceProvider.Validate(greenCoursesBoxes, examCollideCheck);
if (res != null)
{
greenCoursesBoxes.Clear();
greenCoursesBoxes.Add(res[0]);
}
}
new AlgorithmLogicProvider().Run(courseScore, whiteCourses, greenCourses, minUnitsRequired, maxUnitsRequired, greenUnits, totalScore, mainCurriculum, greenCoursesBoxes, examCollideCheck, ChoosedWeeklyProgram, timeout);
if (ChoosedWeeklyProgram.Count > 0)
{
model.Succ = true;
}
else
{
model.Succ = false;
}
}//end method Run
private static void PopulateSatelliteInformation(MainCurriculum curriculum, List <SatelliteInformation> satList)
{
BasicRulesStateValidator.PopulateSatelliteInformation(curriculum, satList, new List <int>());
}
/// <summary>
///
/// </summary>
/// <param name="curriculum"></param>
/// <param name="satList">pass empty satLst that created by MainCurriculum.CreateNewSatelliteInformationList() to fill it</param>
/// <param name="takenCoursesId"></param>
public static void PopulateSatelliteInformation(MainCurriculum curriculum, List <SatelliteInformation> satList, List <int> takenCoursesId)
{
bool[] takenCoursesArray = new bool[curriculum.Courses.Count];
takenCoursesId.ForEach(t => takenCoursesArray[t] = true);
PopulateSatelliteInformationHelper(curriculum.Root, satList, curriculum, takenCoursesArray);
}
private static bool RecursiveCourseAcheivableCheckHelper(MainCurriculum curriculum, List <SatelliteInformation> satList, Course c, CourseCategory courseCategory)
{
if (courseCategory == curriculum.Root)
{
return(true);
}
else
{
List <CourseCategory> allowedCourseCategories = new List <CourseCategory>();
for (int i = 0; i < courseCategory.InputGates.Count; i++)
{
var graphEdge = courseCategory.InputGates[i];
if (!graphEdge.IsAllowedAllCredits(curriculum.StudentCredit))
{
continue;
}
bool graphEdgeCon = true;
for (int j = 0; j < graphEdge.CertificateList.Count; j++)
{
var crt = graphEdge.CertificateList[j];
for (int m = 0; m < crt.ConstraintList.Count; m++)
{
var constraint = crt.ConstraintList[m];
if (constraint is MinNumberMaxNumberOfCoursesConstraint)
{
graphEdgeCon = constraint.IsOk(satList[courseCategory.Id].NumberOfCoursesPassed + 1);
}
else if (constraint is MinUnitsMaxUnitsOfCoursesConstraint)
{
graphEdgeCon = constraint.IsOk(satList[courseCategory.Id].UnitsOfCoursesPassed + c.Units);
}
else if (constraint is NumberOfCoursesMustBeLabOrWorkshopConstraint)
{
graphEdgeCon = constraint.IsOk(satList[courseCategory.Id].NumberOfWorkshopOrLabPassed + (c.IsLabOrWorkshop() ? 1 : 0));
}
else if (constraint is UnitOfCoursesMustBeLabOrWorkshopConstraint)
{
graphEdgeCon = constraint.IsOk(satList[courseCategory.Id].UnitsOfWorkshopOrLabPassed + (c.IsLabOrWorkshop() ? c.Units : 0));
}
else
{
throw new ArgumentException();
}
if (!graphEdgeCon)
{
break;
}
}
if (!graphEdgeCon)
{
break;
}
}
if (graphEdgeCon)
{
allowedCourseCategories.Add(graphEdge.SrcCourseCategory);
}
}
bool suuc = false;
for (int i = 0; i < allowedCourseCategories.Count; i++)
{
var accc = allowedCourseCategories[i];
if (RecursiveCourseAcheivableCheckHelper(curriculum, satList, c, accc))
{
suuc = true;
break;
}
}
return(suuc);
}
}
private static void PopulateSatelliteInformationHelper(CourseCategory courseCategory, List <SatelliteInformation> satList, MainCurriculum curriculum, bool[] takenCoursesArray)
{
if (courseCategory.IsEdge())
{
courseCategory.Courses.ForEach(c =>
{
if (c.IsPassed || takenCoursesArray[c.Id])//*v.i
{
satList[courseCategory.Id].NumberOfCoursesPassed += 1;
satList[courseCategory.Id].UnitsOfCoursesPassed += c.Units;
if (c.IsLabOrWorkshop())
{
satList[courseCategory.Id].NumberOfWorkshopOrLabPassed += 1;
satList[courseCategory.Id].UnitsOfWorkshopOrLabPassed += c.Units;
}
}
});
}
else
{
courseCategory.OutputGates.ForEach(og =>
{
var courseCategoryChild = og.DesCourseCategory;
var courseCategorySrc = og.SrcCourseCategory;
if (og.IsAllowedAllCredits(curriculum.StudentCredit))
{
//first calc
PopulateSatelliteInformationHelper(courseCategoryChild, satList, curriculum, takenCoursesArray);
//then set values
satList[courseCategorySrc.Id].NumberOfCoursesPassed += satList[courseCategoryChild.Id].NumberOfCoursesPassed;
satList[courseCategorySrc.Id].UnitsOfCoursesPassed += satList[courseCategoryChild.Id].UnitsOfCoursesPassed;
satList[courseCategorySrc.Id].NumberOfWorkshopOrLabPassed += satList[courseCategoryChild.Id].NumberOfWorkshopOrLabPassed;
satList[courseCategorySrc.Id].UnitsOfWorkshopOrLabPassed += satList[courseCategoryChild.Id].UnitsOfWorkshopOrLabPassed;
}
});
}
}
private static bool Acheivable(bool[] visited, bool[] achivable, MainCurriculum curriculum, List <SatelliteInformation> satList, Course c, int cntPassedUnits, int currentTermNumber)
{
//memoization :=> dynamic programming
if (visited[c.Id])
{
return(achivable[c.Id]);
}
if (!c.IsAvailable())
{
return(false);
}
else if (c.IsPassed)
{
return(false);
}
else if (c.MinRequireTerm > currentTermNumber)
{
return(false);
}
else if (c.MinReuireUnits > cntPassedUnits)
{
return(false);
}
for (int i = 0; i < c.PrerequisiteCourses.Count; i++)
{
var pr = c.PrerequisiteCourses[i];
if (!pr.IsPassed)
{
if (pr.NumberOfFailed > 1)
{
if (!Acheivable(visited, achivable, curriculum, satList, pr, cntPassedUnits, currentTermNumber))
{
return(false);
}
}
else
{
return(false);
}
}
}
for (int i = 0; i < c.RequisiteCourses.Count; i++)
{
var r = c.RequisiteCourses[i];
if (!r.IsAvailable())
{
return(false);
}
if (r.IsPassed == false && !Acheivable(visited, achivable, curriculum, satList, r, cntPassedUnits, currentTermNumber))
{
return(false);
}
}
var res = RecursiveCourseAcheivableCheck(curriculum, satList, c);
//memoization
visited[c.Id] = true;
achivable[c.Id] = res;
return(res);
}
private static bool PrerequisitesAndRequisitesRegardedPreRequisitesHelper(Course course, MainCurriculum curriculum, bool[] takenCoursesArray)
{
bool succ = true;
for (int i = 0; i < course.PrerequisiteCourses.Count; i++)
{
var curr = course.PrerequisiteCourses[i];
if (!curr.IsPassed)
{
if (curr.NumberOfFailed > 1)
{
if (!takenCoursesArray[curr.Id])
{
succ = false;
break;
}
}
else
{
succ = false;
break;
}
}
}
return(succ);
}
/// <summary>
///
/// </summary>
/// <param name="curriculum"></param>
/// <param name="satList">pass satList that filled by MainCurriculumSateValidator.PopulateSatelliteInformation()</param>
/// <returns></returns>
public static bool IsValidState(MainCurriculum curriculum, List <SatelliteInformation> satList)
{
return(IsValidStateHelper(curriculum, satList, curriculum.Root));
}
private static bool IsValidStateHelper(MainCurriculum curriculum, List <SatelliteInformation> satList, CourseCategory courseCategory)
{
if (courseCategory.IsEdge())
{
return(true);
}
var graphEdges = courseCategory.OutputGates;
for (int i = 0; i < graphEdges.Count; i++)
{
var graphEdge = graphEdges[i];
if (graphEdge.IsAllowedAllCredits(curriculum.StudentCredit))
{
var crtLst = graphEdge.CertificateList;
bool isOk = true;
for (int j = 0; j < crtLst.Count; j++)
{
var crt = crtLst[j];
for (int m = 0; m < crt.ConstraintList.Count; m++)
{
var constraint = crt.ConstraintList[m];
if (constraint is MinNumberMaxNumberOfCoursesConstraint)
{
isOk = constraint.IsOk(satList[graphEdge.DesCourseCategory.Id].NumberOfCoursesPassed);
}
else if (constraint is MinUnitsMaxUnitsOfCoursesConstraint)
{
isOk = constraint.IsOk(satList[graphEdge.DesCourseCategory.Id].UnitsOfCoursesPassed);
}
else if (constraint is NumberOfCoursesMustBeLabOrWorkshopConstraint)
{
isOk = constraint.IsOk(satList[graphEdge.DesCourseCategory.Id].NumberOfWorkshopOrLabPassed);
}
else if (constraint is UnitOfCoursesMustBeLabOrWorkshopConstraint)
{
isOk = constraint.IsOk(satList[graphEdge.DesCourseCategory.Id].UnitsOfWorkshopOrLabPassed);
}
else
{
throw new Exception();
}
if (!isOk)
{
break;
}
}
if (!isOk)
{
break;
}
}
if (!isOk)
{
return(false);
}
if (IsValidStateHelper(curriculum, satList, graphEdge.DesCourseCategory) == false)
{
return(false);
}
}
}
return(true);
}
