public IActionResult GetUoftTimetables([FromBody] TimetableRequest request)
{
if (request == null)
{
return(BadRequest());
}
// Each course code has a length of 10; max 10 courses to put in timetable
if (request.CourseCodes == null || request.CourseCodes.Length > 100)
{
return(BadRequest());
}
// Check if the preferences / restrictions are set
if (request.Preferences == null || request.Restrictions == null)
{
return(BadRequest());
}
// Get the courses from the database
List <Activity> activities = new List <Activity>();
foreach (string code in request.CourseCodes)
{
Course courseObj = UoftServices.GetService().GetCourseDetails(code);
if (courseObj == null)
{
return(NotFound());
}
activities.AddRange(courseObj.Activities);
}
// Generate the timetables
TimetableScorer scorer = new TimetableScorer(request.Restrictions, request.Preferences);
GeneticScheduler <YearlyTimetable> generator = new GeneticScheduler <YearlyTimetable>(activities, scorer, request.Preferences, request.Restrictions)
{
NumGenerations = 100,
PopulationSize = 16,
MutationRate = 0.1,
CrossoverRate = 0.6
};
List <YearlyTimetable> timetables = generator.GetTimetables();
/*
* GreedyScheduler<YearlyTimetable> greedyGenerator = new GreedyScheduler<YearlyTimetable>(activities, request.Preferences, request.Restrictions);
* List<YearlyTimetable> timetables = greedyGenerator.GetTimetables();
*/
// Convert the timetables to mini timetables (which will be presented to the user)
List <SimplifiedYearlyTimetable> miniTimetables = new List <SimplifiedYearlyTimetable>();
for (int i = 0; i < timetables.Count; i++)
{
miniTimetables.Add(new SimplifiedYearlyTimetable(timetables[i], "Timetable #" + (i + 1)));
}
return(Created("api/timetables/getuofttimetables", miniTimetables));
}
//! get max Number of Generations
/*!
* /param schedulerInterface scheduler to read nr. Of Generations
* /return int number of generations or zero if scheduler unsuported
* only for genetic scheduler will
*/
public static int getNumberOfGeneration(SchedulerInterface scheduler)
{
if (scheduler.GetType() == typeof(GeneticScheduler))
{
GeneticScheduler genetic = (GeneticScheduler)scheduler;
return(genetic.getNrOfGenerations());
}
return(0);
}
//! set Scheduler
/*!
* /param SChedulerInterface scheduler to set up
* /param Main mainform to update = null
* reads the settings set and sets up the scheduler bases on its type
*/
public static SchedulerInterface setScheduler(SchedulerInterface scheduler, Main UpdateForm = null)
{
if (scheduler.GetType() == typeof(GeneticScheduler))
{
GeneticScheduler genetic = (GeneticScheduler)scheduler;
if (Properties.Settings.Default.genetic_Run_For_MaxTime == true)
{
genetic.RunForCertainTime(true, Properties.Settings.Default.genetic_RunTime);
}
genetic.setCreationPercentage(Properties.Settings.Default.genetic_Start_Percentage);
genetic.setMaxNumberOfGeneration(Properties.Settings.Default.genetic_Max_Nr_of_Generations);
genetic.setMutationPercentage(Properties.Settings.Default.genetic_Mutation_Chance);
genetic.setPopulationSize(Properties.Settings.Default.genetic_Population_Size);
genetic.setSolveConflictsAfterRun(Properties.Settings.Default.genetic_SolveContflicts);
genetic.setConflictHandeling(Properties.Settings.Default.genetic_ConflictSolver);
genetic.setFormToUpdate(UpdateForm);
scheduler = genetic;
}
if (scheduler.GetType() == typeof(HillClimberScheduler))
{
HillClimberScheduler hillclimber = (HillClimberScheduler)scheduler;
hillclimber.setFormToUpdate(UpdateForm);
hillclimber.setAdaptiveMaxIterationbs(Properties.Settings.Default.hill_adaptiveMaxIterations);
hillclimber.setMaxNumberOfIterations(Properties.Settings.Default.hill_maxNumberIterations);
hillclimber.setRandomStart(Properties.Settings.Default.hill_randomStart);
scheduler = hillclimber;
}
if (scheduler.GetType() == typeof(EftGreedyScheduler))
{
EftGreedyScheduler eftGreedy = (EftGreedyScheduler)scheduler;
eftGreedy.setFormToUpdate(UpdateForm);
scheduler = eftGreedy;
}
if (scheduler.GetType() == typeof(GreedyScheduler))
{
GreedyScheduler greedy = (GreedyScheduler)scheduler;
greedy.setFormToUpdate(UpdateForm);
scheduler = greedy;
}
/*
* if (schduler.GetType() == typeof(ExampleScheduler))
* {
* set scheduler settings
*
* }
*/
return(scheduler);
}
static void RunHeuristic()
{
FileInfo existingFile = new FileInfo("Input.xlsx");
var context = ExcelHelper.Read(existingFile);
context.Init();
heuristicScheduler = new HeuristicScheduler(context);
Schedule schedule = heuristicScheduler.Run();
context.FillDetails = true;
SchedulingFitness evaluator = new SchedulingFitness(context);
double penaltyScore = evaluator.EvaluateAll(schedule);
Console.WriteLine("Penalty score: " + penaltyScore);
scheduler = new GeneticScheduler(context);
ExcelHelper.Write(@"..\..\Results\Done_He_" + DateTime.Now.ToString("yyyyMMdd_HHmm") + ".xlsx", schedule, context, scheduler.GetFinalScores(schedule, evaluator));
}
static void RunGenetic()
{
var watch = Stopwatch.StartNew();
FileInfo existingFile = new FileInfo("Input.xlsx");
var context = ExcelHelper.Read(existingFile);
context.Init();
scheduler = new GeneticScheduler(context);
var task = scheduler.RunAsync().ContinueWith(scheduleTask =>
{
Schedule resultSchedule = scheduleTask.Result;
string elapsed = watch.Elapsed.ToString();
SchedulingFitness evaluator = new SchedulingFitness(context);
double penaltyScore = evaluator.EvaluateAll(resultSchedule);
Console.WriteLine("Penalty score: " + penaltyScore);
ExcelHelper.Write(@"..\..\Results\Done_Ge_" + DateTime.Now.ToString("yyyyMMdd_HHmm") + ".xlsx", scheduleTask.Result, elapsed, scheduler.GenerationFitness, scheduler.GetFinalScores(resultSchedule, scheduler.Fitness), context);
}
);
while (true)
{
if (task.IsCompleted)
{
break;
}
var ch = Console.ReadKey();
if (ch.Key == ConsoleKey.A)
{
scheduler.Cancel();
}
Console.WriteLine("Press A to Abort");
}
Console.WriteLine();
}
/// <summary>
/// Update the statistical data in the charts
/// </summary>
private void UpdateStats()
{
// Get the parameters
double mutationRate = Convert.ToDouble(mutationRateTxtbox.Text);
double crossoverRate = Convert.ToDouble(crossoverRateTxtbox.Text);
int numGenerations = Convert.ToInt32(numGenTxtbox.Text);
int populationSize = Convert.ToInt32(popSizeTxtbox.Text);
string crossoverType = crossoverMethodBox.Text;
// Get average scores per generation for over 30 trials
int numTrials = 100;
StatsPerGeneration[][] fullStats = new StatsPerGeneration[numTrials][];
/*
* Parallel.For(0, numTrials, delegate (int i)
* {
* // Make generator with params
* GAGenerator generator = new GAGenerator(courses, preferences, restrictions)
* {
* MutationRate = mutationRate,
* CrossoverRate = crossoverRate,
* NumGenerations = numGenerations,
* PopulationSize = populationSize,
* CrossoverType = crossoverType
* };
*
* // Run the generator and get stats
* StatsPerGeneration[] curStats = generator.GenerateTimetablesWithStats();
* fullStats[i] = curStats;
* });
*/
for (int i = 0; i < numTrials; i++)
{
// Make generator with params
GeneticScheduler <YearlyTimetable> generator = new GeneticScheduler <YearlyTimetable>(null, null, preferences, restrictions)
{
MutationRate = mutationRate,
CrossoverRate = crossoverRate,
NumGenerations = numGenerations,
PopulationSize = populationSize
};
// Run the generator and get stats
StatsPerGeneration[] curStats = generator.GenerateTimetablesWithStats();
fullStats[i] = curStats;
}
// Compute the average over the x trials
StatsPerGeneration[] avgStats = new StatsPerGeneration[numGenerations];
for (int i = 0; i < numGenerations; i++)
{
StatsPerGeneration sum = fullStats[0][i];
for (int j = 1; j < numTrials; j++)
{
sum += fullStats[j][i];
}
avgStats[i] = sum / numTrials;
}
// Set up the data
scoresChart.Series.Clear();
scoresChart.ChartAreas[0].AxisY.Minimum = 0;
scoresChart.Series.Add("Average Scores");
scoresChart.Series["Average Scores"].ChartType = SeriesChartType.Spline;
scoresChart.Series.Add("Max Scores");
scoresChart.Series["Max Scores"].ChartType = SeriesChartType.Spline;
// Add the average / maxscores to the chart by their type
for (int i = 0; i < numGenerations; i++)
{
scoresChart.Series["Average Scores"].Points.Add(new DataPoint(i, avgStats[i].AverageScores));
scoresChart.Series["Max Scores"].Points.Add(new DataPoint(i, avgStats[i].MaxScores));
}
// Add performance data
performanceChart.Series.Clear();
performanceChart.ChartAreas[0].AxisY.Minimum = 0;
performanceChart.Series.Add("Time ellapsed (ms)");
performanceChart.Series["Time ellapsed (ms)"].ChartType = SeriesChartType.Spline;
for (int i = 0; i < numGenerations; i++)
{
performanceChart.Series["Time ellapsed (ms)"].Points.Add(new DataPoint(i, avgStats[i].Runtime));
}
// Add diversity data
diversityChart.Series.Clear();
diversityChart.ChartAreas[0].AxisY.Minimum = 0;
diversityChart.Series.Add("Diversity (%)");
diversityChart.Series["Diversity (%)"].ChartType = SeriesChartType.Spline;
for (int i = 0; i < numGenerations; i++)
{
diversityChart.Series["Diversity (%)"].Points.Add(new DataPoint(i, avgStats[i].PopulationDiversity * 100));
}
}
