diff --git a/algorithm.c b/algorithm.c
new file mode 100644
index 0000000..a54b9d0
--- /dev/null
+++ b/algorithm.c
@@ -0,0 +1,745 @@
+/*
+ * Colloscope - A program that generates a colloscope for French 'classes prépas'
+ * Copyright (C) 2024 Alexandre Aboujaib
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+
+#include
+#include
+#include
+
+#include "logger.h"
+#include "structure.h"
+#include "algorithm.h"
+
+bool is_equal_date(date d1, date d2) {
+ return (d1.hour == d2.hour && d1.day == d2.day && d2.month == d1.month && d2.year == d1.year);
+}
+
+int get_date_index(creneau* edt, int len_creneau, date d) {
+ // could be done in log(n), I know
+ // yields the 1st occurence of d in edt
+ int x = -1;
+ for(int i = 0; i < len_creneau; i++) {
+ x = date_dist(d, edt[i].date);
+ if(x >= 0) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+int get_next_friday(creneau* edt, int len_creneau, date d) {
+ // could be done in log(n), I know again
+ int x = -1;
+ for(int i = 0; i < len_creneau; i++) {
+ x = date_dist(d, edt[i].date);
+ if(x >= 0 && (i == len_creneau-1 || date_dist(d, edt[i+1].date) - x > 1)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+// typedef struct colleur {char* name; int namelen; topic mat; date* disp; int n_disp;} colleur;
+colleur* get_colleurs(colleur* cl, int len_cl, date d, int* how_many) {
+ colleur* res = malloc(sizeof(colleur)*30); // max. 3 colles per creneau
+ int ptr = 0;
+ for(int i = 0; i < len_cl; i++) {
+ for(int j = 0; j < cl[i].n_disp; j++) {
+ if(is_equal_date(cl[i].disp[j], d)) {
+ if(ptr >= 30) {
+ warn("Too many colleurs detected for a creneau\n");
+ }
+ res[ptr] = cl[i];
+ ptr++;
+ j = cl[i].n_disp;
+ }
+ }
+ }
+ *how_many = ptr;
+ return res;
+}
+
+void swap(int* arr, int i, int j) {
+ if(i != j) {
+ arr[i] += arr[j];
+ arr[j] = arr[i] - arr[j];
+ arr[i] -= arr[j];
+ }
+}
+
+void generate_random_perm(int* arr, int len) {
+ // generate a random perm of int between 0 and len-1
+ for(int i = 0; i < len; i++) {
+ arr[i] = i;
+ }
+ for(int i = 0; i < len; i++) {
+ swap(arr, i, rand()%len);
+ }
+}
+
+void print_arr(int* arr, int len) {
+ printf("[");
+ for(int i = 0; i < len; i++) {
+ printf("%d ", arr[i]);
+ }
+ printf("]\n");
+}
+
+void add_colle(creneau* edt, colleur* chads, int grp, int id_edt, int id_chad) {
+ edt[id_edt].group = grp;
+ edt[id_edt].namelen = chads[id_chad].namelen;
+ str_copy(chads[id_chad].name, chads[id_chad].namelen, edt[id_edt].name);
+ edt[id_edt].mat = chads[id_chad].mat;
+}
+
+void remove_colle(creneau* edt, int id_edt) {
+ edt[id_edt].group = 0;
+ edt[id_edt].namelen = 0;
+ str_copy("none", 4, edt[id_edt].name);
+ edt[id_edt].mat = NOTHING;
+}
+
+void move_colle(creneau* edt, int len_edt, int id_src, int id_dest) {
+ if((id_src < len_edt && id_src >= 0 && id_dest < len_edt && id_dest >= 0) == false) {
+ printf("Bad\n");
+ exit(1);
+ }
+
+ edt[id_dest].group = edt[id_src].group;
+ edt[id_dest].namelen = edt[id_src].namelen;
+ str_copy(edt[id_src].name, edt[id_src].namelen, edt[id_dest].name);
+ edt[id_dest].mat = edt[id_src].mat;
+
+ remove_colle(edt, id_src);
+}
+
+int mem_id(creneau* edt, int len_edt, int grp, char* colleur, int offset) {
+ for(int i = offset; i < len_edt; i++) {
+ if(edt[i].group == grp && str_equal(edt[i].name, colleur)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+bool is_overlap(creneau* edt, int len_edt, int id) { // detect if a colleur has 2 colles at the same time
+ int k = 1;
+ while(id+k < len_edt && is_equal_date(edt[id].date, edt[id+k].date)) {
+ if(str_equal(edt[id].name, edt[id+k].name)) {
+ return true;
+ }
+ k++;
+ }
+ k = 1;
+ while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
+ if(str_equal(edt[id].name, edt[id-k].name)) {
+ return true;
+ }
+ k++;
+ }
+ return false;
+}
+
+bool is_overlap_creneau(creneau* edt, int len_edt, int id, int grp) { // detect if a group has 2 overlapping colles
+ int k = 1;
+ while((id+k < len_edt && edt[id+k].date.hour - edt[id].date.hour < edt[id].length) && edt[id+k].date.day == edt[id].date.day) {
+ if(edt[id+k].group == grp) {
+ return true;
+ }
+ k++;
+ }
+ k = 1;
+ while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
+ if(edt[id+k].group == grp) {
+ return true;
+ }
+ k++;
+ }
+ return false;
+}
+
+int free_math_space(creneau* edt, int len_edt, int id) {
+ int k = 1;
+ int howmany = 0;
+ while(id+k < len_edt && is_equal_date(edt[id].date, edt[id+k].date)) {
+ if(edt[id+k].mat == NOTHING || edt[id+k].mat == MATH) {
+ howmany++;
+ }
+ k++;
+ }
+ k = 1;
+ while(id-k >= 0 && is_equal_date(edt[id].date, edt[id-k].date)) {
+ if(edt[id-k].mat == NOTHING || edt[id-k].mat == MATH) {
+ howmany++;
+ }
+ k++;
+ }
+ return howmany;
+}
+
+void add_colles_for_group_MP2I(int* weeks_len, creneau* edt, int len_edt, colleur* chads, int len_chads, int n_weeks, int grp, topic start_rotation, int mth, int inf, int* skip_count, int mat_halt, int info_app) {
+ topic rotation = start_rotation; // physics/english rotation
+ int math = mth; // math (3/4)
+ int info = inf; // info (1/6)
+
+ int r; // randomize the 1st date
+ int k = 0; // offset
+ int halt = 0; // timeout in case a colle cannot be placed
+ bool found; // interrupt in case a valid colle has been found
+
+ int remaining_to_add = 0; /* self-explainatory
+ please note that this also tells what colle to add :
+ 1 = physics/english colle
+ 2 = math
+ 3 (not implemented) = info
+ */
+ int len_dudes = 0; // length of colleur*
+
+ int len_perm = 0; // length of int*
+
+ int math_dude = 0; // length of colleur*
+ int weeklen;
+
+ bool normal_skip = true;
+
+ for(int week = 0; week < n_weeks; week++) {
+
+ weeklen = weeks_len[week];
+ // update what colles to add
+ if(mat_halt == 1 || math == 0) {
+ math = mat_halt-1;
+ } else {
+ remaining_to_add++;
+ math--;
+ }
+ if(rotation == ENGLISH) {
+ rotation = PHYSICS;
+ } else {
+ rotation = ENGLISH;
+ }
+
+ remaining_to_add++; // physics/english
+
+ // initialize/reset variables
+ r = rand()%weeklen;
+ halt = 0;
+ found = false;
+ normal_skip = true;
+
+ info++;
+ // info colle
+ while(info >= info_app) {
+ if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 2) {
+ // if creneau is empty
+ // import all colleurs available
+ colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
+ len_perm = len_dudes;
+
+ // if there are colleurs available
+ if(len_dudes != 0) {
+
+ // randomize the order of colleurs
+ int* perm = malloc(sizeof(int)*len_perm);
+ generate_random_perm(perm, len_perm);
+
+ // for each one of them, add his colle for selected group pf and only if
+ // - he is a INFO colleur
+ // if a colle has been addded, interrupt the for andwhile loops
+ for(int dude = 0; dude < len_perm*(1-found); dude++) {
+ if(dudes[perm[dude]].mat == INFO && edt[k+r%weeklen].allow_grps[grp-1] == true) {
+ add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
+ found = true;
+ info = 0;
+ } else if(edt[k+r%weeklen].allow_grps[grp-1] == true) {
+ normal_skip = false;
+ }
+ }
+ free(perm);
+ }
+ free(dudes);
+ }
+ if(!found && halt > weeklen) {
+ info = 0;
+ *skip_count += (1-normal_skip);
+ }
+ r++;
+ halt++;
+ }
+ // reset the variables
+ r = rand()%weeklen;
+ found = false;
+ halt = 0;
+ normal_skip = true;
+
+ // if there is a math colle to add, enter this loop
+ while(remaining_to_add == 2) {
+
+ if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 1) {
+ // if creneau is empty
+ // import all colleurs available
+ colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
+ len_perm = len_dudes;
+
+ // if there are colleurs available
+ if(len_dudes != 0) {
+
+ // randomize the order of colleurs
+ int* perm = malloc(sizeof(int)*len_perm);
+ generate_random_perm(perm, len_perm);
+
+ // for each one of them, add his colle for selected group pf and only if
+ // - he is a MATH colleur
+ // - he does not have another colle at the same time (is_overlap)
+ // if a colle has been addded, interrupt the for andwhile loops
+ for(int dude = 0; dude < len_perm*(1-found); dude++) {
+ if(dudes[perm[dude]].mat == MATH && edt[k+r%weeklen].allow_grps[grp-1] == true) {
+ add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
+ if(is_overlap(edt, len_edt, k+r%weeklen)) {
+ remove_colle(edt, k+r%weeklen);
+ } else {
+ found = true;
+ remaining_to_add--;
+ }
+ }
+ }
+ free(perm);
+ }
+ free(dudes);
+ }
+ if(!found && halt > weeklen) {
+ remaining_to_add--;
+ *skip_count += 1;
+ }
+ r++;
+ halt++;
+ }
+ // reset the variables
+ r = rand()%weeklen;
+ found = false;
+ halt = 0;
+
+ // do it again for physics/english colles
+ while(remaining_to_add == 1) {
+ if(edt[k+r%weeklen].mat == NOTHING && edt[k+r%weeklen].length == 1) {
+ colleur* dudes = get_colleurs(chads, len_chads, edt[k+r%weeklen].date, &len_dudes);
+ len_perm = len_dudes;
+ if(len_dudes != 0) {
+ int* perm = malloc(sizeof(int)*len_perm);
+ generate_random_perm(perm, len_perm);
+ math_dude = 0;
+ for(int dude = 0; dude < len_dudes; dude++) {
+ if(dudes[dude].mat == MATH) {
+ math_dude++;
+ }
+ }
+ for(int dude = 0; dude < len_perm*(1-found); dude++) {
+ if(dudes[perm[dude]].mat == rotation && edt[k+r%weeklen].allow_grps[grp-1] == true) {
+ add_colle(edt, dudes, grp, k+r%weeklen, perm[dude]);
+ if(math_dude > free_math_space(edt, len_edt, k+r%weeklen) || is_overlap(edt, len_edt, k+r%weeklen)) {
+ remove_colle(edt, k+r%weeklen);
+ } else {
+ found = true;
+ remaining_to_add--;
+ }
+ }
+ }
+ free(perm);
+ }
+ free(dudes);
+ }
+ if(!found && halt > weeks_len[week]) {
+ remaining_to_add--;
+ *skip_count += 1;
+ }
+ r++;
+ halt++;
+ }
+
+ k += weeks_len[week];
+ remaining_to_add = 0;
+ }
+}
+
+void write_to_file(char* filename, creneau* edt, int len_edt) {
+ FILE* ptr = fopen(filename, "w");
+ fprintf(ptr, "hour,day,month,year,length,group,colleur,matiere\n");
+ for(int i = 0; i < len_edt; i++) {
+ fprintf(ptr, "%d,%d,%d,%d,%d,%d,%s,", edt[i].date.hour, edt[i].date.day, edt[i].date.month, edt[i].date.year, edt[i].length, edt[i].group, edt[i].name);
+ if(edt[i].mat == NOTHING) {
+ fprintf(ptr, "_");
+ } else if(edt[i].mat == MATH) {
+ fprintf(ptr, "Maths");
+ } else if(edt[i].mat == PHYSICS) {
+ fprintf(ptr, "Physique");
+ } else if(edt[i].mat == ENGLISH) {
+ fprintf(ptr, "Anglais");
+ } else if(edt[i].mat == INFO) {
+ fprintf(ptr, "Info");
+ } else if(edt[i].mat == FRENCH) {
+ fprintf(ptr, "Français");
+ } else {
+ fprintf(ptr, "Unknown");
+ }
+ fprintf(ptr, "\n");
+ }
+ fclose(ptr);
+}
+
+int min(int x, int y) {
+ if(x < y) {
+ return x;
+ }
+ return y;
+}
+
+int max(int x, int y) {
+ if(x > y) {
+ return x;
+ }
+ return y;
+}
+
+int score(creneau* edt, int len_edt, int grp, int n_weeks) {
+ int score = 100;
+
+ int dist = 0;
+ for(int i = 0; i < len_edt; i++) {
+ for(int j = i+1; j < len_edt; j++) {
+ if(edt[i].group == grp && edt[j].group == grp) {
+ dist = date_dist(edt[i].date, edt[j].date);
+ if(dist == 0) {
+ score -= 4;
+ }
+ /*if(str_equal(edt[i].name, edt[j].name)) {
+ score -= max(0, 28-dist);
+ }*/
+ if(dist == 7 && edt[i].date.hour == edt[j].date.hour) {
+ score -= 5;
+ }
+ if(dist < 5 && edt[i].date.hour == 18 && edt[j].date.hour == 18) {
+ score -= 5;
+ }
+ }
+ }
+ }
+
+ char** met = malloc(sizeof(char*)*3*n_weeks);
+ int p = 0;
+ for(int i = 0; i < len_edt; i++) {
+ if(edt[i].group == grp) {
+ met[p] = malloc(sizeof(char)*30);
+ str_copy(edt[i].name, edt[i].namelen, met[p]);
+ for(int k = p-1; k >= 0; k--) {
+ if(str_equal(met[k], met[p])) {
+ switch(edt[i].mat) {
+ case MATH:
+ score -= 12;
+ break;
+ case PHYSICS:
+ score -= 12;
+ break;
+ case ENGLISH:
+ score -= 12;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ p++;
+ }
+ }
+
+ for(int f = 0; f < p; f++) {
+ free(met[f]);
+ }
+ free(met);
+ return score;
+}
+
+int get_colleur_id(colleur* dudes, int n_dudes, char* target) {
+ for(int i = 0; i < n_dudes; i++) {
+ if(str_equal(dudes[i].name, target)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+char* get_name_from_id(colleur* dudes, int n_dudes, int id) {
+ for(int i = 0; i < n_dudes; i++) {
+ if(id == dudes[i].id) {
+ return dudes[i].name;
+ }
+ }
+ return "none";
+}
+
+topic get_mat_from_id(colleur* dudes, int n_dudes, int id) {
+ for(int i = 0; i < n_dudes; i++) {
+ if(id == dudes[i].id) {
+ return dudes[i].mat;
+ }
+ }
+ return NOTHING;
+}
+
+int** generate_matrix(int lines, int columns, int def) {
+ int** mat = malloc(sizeof(int*)*lines);
+ for(int i = 0; i < lines; i++) {
+ mat[i] = malloc(sizeof(int)*columns);
+ for(int j = 0; j < columns; j++) {
+ mat[i][j] = def;
+ }
+ }
+ return mat;
+}
+
+void destroy_matrix(int** m, int li) {
+ for(int i = 0; i < li; i++) {
+ free(m[i]);
+ }
+ free(m);
+}
+
+bool retreive_indexes(creneau* edt, int len_edt, int* p1, int* p2, int g1, int g2, char* n1, char* n2, int n_weeks) {
+ int* indexes_1 = malloc(sizeof(int)*n_weeks);
+ int* indexes_2 = malloc(sizeof(int)*n_weeks);
+ int ptr_1 = 0;
+ int ptr_2 = 0;
+
+ for(int i = 0; i < len_edt; i++) {
+ if(edt[i].group == g1 && str_equal(edt[i].name, n1)) {
+ indexes_1[ptr_1] = i;
+ ptr_1++;
+ } else if(edt[i].group == g2 && str_equal(edt[i].name, n2)) {
+ indexes_2[ptr_2] = i;
+ ptr_2++;
+ }
+ }
+ int j = 0;
+ for(int i = 0; i < ptr_1; i++) {
+ if(j >= ptr_2) {
+ free(indexes_1);
+ free(indexes_2);
+ return false;
+ } else {
+ int friday_1 = get_next_friday(edt, len_edt, edt[indexes_1[i]].date);
+ int friday_2 = get_next_friday(edt, len_edt, edt[indexes_2[j]].date);
+ if(friday_1 == friday_2) {
+ *p1 = indexes_1[i];
+ *p2 = indexes_2[j];
+
+ free(indexes_1);
+ free(indexes_2);
+ return true;
+ } else {
+ if(friday_1 > friday_2) {
+ i--;
+ j++;
+ }
+ }
+ }
+ }
+
+ free(indexes_1);
+ free(indexes_2);
+ return false;
+}
+
+int** occurencies(creneau* edt, int len_edt, colleur* dudes, int n_groups, int n_colleurs, int n_weeks, bool is_debug) {
+ int max_occ = 1;
+ int** res = generate_matrix(n_groups, n_colleurs, 0);
+
+ for(int c = 0; c < len_edt; c++) {
+ if(edt[c].group != 0) {
+ res[edt[c].group-1][get_colleur_id(dudes, n_colleurs, edt[c].name)] += 1;
+ }
+ }
+
+ bool halt = false;
+ for(int it = 0; it < 5*(1-is_debug); it++) {
+ for(int grp = 0; grp < n_groups; grp++) {
+ for(int dud = 0; dud < n_colleurs; dud++) {
+ if(res[grp][dud] > max_occ && get_mat_from_id(dudes, n_colleurs, dud) != INFO) {
+ for(int grp2 = 0; grp2 < n_groups*(1-halt); grp2++) {
+ if(grp2 != grp) {
+ for(int dud2 = 0; dud2 < n_colleurs*(1-halt); dud2++) {
+ if(dud2 != dud && res[grp2][dud2] > max_occ && res[grp][dud2] < max_occ && res[grp2][dud] < max_occ && get_mat_from_id(dudes, n_colleurs, dud) == get_mat_from_id(dudes, n_colleurs, dud2)) {
+
+ int id_src;
+ int id_dest;
+ if(retreive_indexes(edt, len_edt, &id_src, &id_dest, grp+1, grp2+1, get_name_from_id(dudes, n_colleurs, dud), get_name_from_id(dudes, n_colleurs, dud2), n_weeks)) {;
+
+ if(id_src < 0 || id_dest < 0 || id_src >= len_edt || id_dest >= len_edt) {
+ printf("Uh oh (%d %d)\n", id_src, id_dest);
+ exit(1);
+ }
+
+ res[grp][dud] -= 1;
+ res[grp2][dud2] -= 1;
+ res[grp2][dud] += 1;
+ res[grp][dud2] += 1;
+
+ edt[id_src].group += edt[id_dest].group;
+ edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
+ edt[id_src].group -= edt[id_dest].group;
+
+ if(is_overlap_creneau(edt, len_edt, id_src, grp2+1)) {
+ res[grp][dud] -= 1;
+ res[grp2][dud2] -= 1;
+ res[grp2][dud] += 1;
+ res[grp][dud2] += 1;
+
+ edt[id_src].group += edt[id_dest].group;
+ edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
+ edt[id_src].group -= edt[id_dest].group;
+ } else if(is_overlap_creneau(edt, len_edt, id_dest, grp+1)) {
+ res[grp][dud] -= 1;
+ res[grp2][dud2] -= 1;
+ res[grp2][dud] += 1;
+ res[grp][dud2] += 1;
+
+ edt[id_src].group += edt[id_dest].group;
+ edt[id_dest].group = edt[id_src].group - edt[id_dest].group;
+ edt[id_src].group -= edt[id_dest].group;
+ } else {
+ halt = true;
+ dud--;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ halt = false;
+ }
+ }
+ }
+
+ return res;
+}
+
+void copy_matrix(int** src, int lines, int col, int** dest) {
+ for(int i = 0; i < lines; i++) {
+ for(int j = 0; j < col; j++) {
+ dest[i][j] = src[i][j];
+ }
+ }
+}
+
+void aux_2(creneau* edt, int len_edt, colleur* chads, int len_chads, int n_groups, int n_weeks, int n_sim, char* outname, int math_halt, int info_app) {
+
+ int start = time(NULL);
+ int* weeks_len = malloc(sizeof(int)*n_weeks);
+ // this list is used to tell the above code what index of edt it has to go to search for a colle
+ int ptr = 0;
+ int current = 1;
+ for(int k = 1; k < len_edt; k++) {
+ if(date_dist(edt[k-1].date, edt[k].date) > 1 || k == len_edt-1) {
+ weeks_len[ptr] = current + (k == len_edt - 1);
+ current = 0;
+ ptr++;
+ }
+ current++;
+ }
+ //printf("----------------------------\n");
+
+ int* group_stats = malloc(sizeof(int)*n_groups);
+ int* group_temp = malloc(sizeof(int)*n_groups);
+
+ int max_score = -900000;
+ int global_min = 0;
+ int global_skipped = 0;
+ int screwed_group = 0;
+ int local_score = 0;
+ int local_min = 0;
+ int local_group = 0;
+ int temp = 0;
+ int skipped = 0;
+ int a = 0;
+ int** occ_data = generate_matrix(n_groups, len_chads, 0);;
+ info("Testing %d combinations...", n_sim);
+ printf("\n");
+ for(int k = 0; k < n_sim*(1 - (max_score == n_groups*100)); k++) {
+ if(k >= a) {
+ printf("\x1b[1F");
+ printf("\x1b[2K");
+ info("%d%% Completed (current max is %d/%d)", 100*a/n_sim, max_score, 100*n_groups);
+ a += n_sim/100;
+ }
+ local_score = 0;
+ local_min = 100;
+ skipped = 0;
+ for(int i = 0; i < n_groups; i++) {
+ add_colles_for_group_MP2I(weeks_len, edt, len_edt, chads, len_chads, n_weeks, i+1, (topic)(2+i%2), i%math_halt, i%info_app, &skipped, math_halt, info_app);
+ }
+ int** temp_data = occurencies(edt, len_edt, chads, n_groups, len_chads, n_weeks, false);
+ for(int i = 0; i < n_groups; i++) {
+ temp = score(edt, len_edt, i+1, n_weeks);
+ local_score += temp;
+ group_temp[i] = temp;
+ if(local_min > temp) {
+ local_min = temp;
+ local_group = i+1;
+ }
+ }
+ local_score -= skipped*30;
+ if(local_score > max_score) {
+ max_score = local_score;
+ screwed_group = local_group;
+ global_min = local_min;
+ global_skipped = skipped;
+ for(int p = 0; p < n_groups; p++) {
+ group_stats[p] = group_temp[p];
+ }
+ copy_matrix(temp_data, n_groups, len_chads, occ_data);
+ write_to_file(outname, edt, len_edt);
+ }
+ for(int r = 0; r < len_edt; r++) {
+ remove_colle(edt, r);
+ }
+ destroy_matrix(temp_data, n_groups);
+ }
+
+ printf("\x1b[1F");
+ printf("\x1b[2K");
+ if(max_score == 100*n_groups) {
+ info("Interrupting early due to a perfect score achieved");
+ } else {
+ info("100%% Completed, best score is %d/%d (without skip penalty) with %d skipped colle(s)", max_score+global_skipped*30, 100*n_groups, global_skipped);
+ info("Most screwed group is %d with a score of %d/100", screwed_group, global_min);
+ debug("Stats for all groups are :");
+ for(int i = 0; i < n_groups; i++) {
+ debug("Group %d : %d/100", i+1, group_stats[i]);
+ }
+ }
+ int end = time(NULL);
+ printf("\n");
+ info("Here is all data regarding colles occurencies :");
+ for(int k = 0; k < n_groups; k++) {
+ printf("Group %d : ", (k+1)%10);
+ print_arr(occ_data[k], len_chads);
+ }
+ info("Took %ds to find", end-start);
+ free(group_stats);
+ free(group_temp);
+ free(weeks_len);
+ destroy_matrix(occ_data, n_groups);
+}
diff --git a/structure.c b/structure.c
new file mode 100644
index 0000000..aa47e31
--- /dev/null
+++ b/structure.c
@@ -0,0 +1,585 @@
+/*
+ * Colloscope - A program that generates a colloscope for French 'classes prépas'
+ * Copyright (C) 2024 Alexandre Aboujaib
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+
+#include
+#include
+#include
+#include
+#include
+
+#include "logger.h"
+#include "structure.h"
+
+//static int width = 1200;
+//static int height = 900;
+int date_dist(date d1, date d2) { /* returns distance between d1 and d2 in days
+ if d2 is sooner than d1, it will return -1 */
+ if(d2.month == d1.month && d2.year == d1.year) {
+ if(d2.day < d1.day) {
+ return -1;
+ }
+ return d2.day - d1.day;
+ } else {
+ int is_31 = 0;
+ if(d1.month == 1 || d1.month == 3 || d1.month == 5 || d1.month == 7 || d1.month == 8 || d1.month == 10 || d1.month == 12) {
+ is_31 = 1;
+ } else {
+ is_31 = (d1.month == 2)*(-2) + (d1.month == 2 && d1.year%4 == 0 && d1.year%100 != 0);
+ }
+ if(d2.month - d1.month < 0 && d2.year <= d1.year) {
+ return -1;
+ } else if(d2.month - d1.month == 1 && d2.year == d1.year) {
+ return d2.day + (30 + is_31 - d1.day);
+ } else {
+ date copy;
+ copy.day = d1.day;
+ copy.month = d1.month;
+ copy.year = d1.year;
+ copy.month = (copy.month + 1);
+ if(copy.month == 13) {
+ copy.month = 1;
+ copy.year += 1;
+ }
+ return (30 + is_31 + date_dist(copy, d2));
+ }
+ }
+}
+
+bool is_sorted(creneau* edt, int len) {
+ for(int i = 1; i < len; i++) {
+ if(date_dist(edt[i-1].date, edt[i].date) == -1) {
+ warn("Anomaly detected at lane %d (dates are not sorted in ascending order) :", i);
+ warn("%d %d %d %d", edt[i-1].date.hour, edt[i-1].date.day, edt[i-1].date.month, edt[i-1].date.year);
+ warn("%d %d %d %d", edt[i].date.hour, edt[i].date.day, edt[i].date.month, edt[i].date.year);
+ warn("%d %d %d %d", edt[i+1].date.hour, edt[i+1].date.day, edt[i+1].date.month, edt[i+1].date.year);
+ return false;
+ }
+ }
+ info("No problem detected");
+ return true;
+}
+
+creneau* import_creneaux(char* filename, int size) {
+ // import creneau data from a file
+ // see file.txt for an example
+ FILE* ptr = fopen(filename, "r");
+ char c = fgetc(ptr);
+
+ creneau* edt = malloc(sizeof(creneau)*size);
+ int i = 0;
+ int to_fill = 0;
+
+ int buffer = 0;
+
+ while(c != EOF && c != '$') {
+ if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer *= 10;
+ buffer += (int)(c) - 48;
+ } else {
+ if(to_fill == 0) {
+ //printf("%d\n", i);
+ edt[i].date.hour = buffer;
+ edt[i].group = 0;
+ edt[i].name = malloc(sizeof(char)*35);
+ edt[i].name[0] = 'n';
+ edt[i].name[1] = 'o';
+ edt[i].name[2] = 'n';
+ edt[i].name[3] = 'e';
+ edt[i].name[4] = '\0';
+ edt[i].namelen = 4;
+ edt[i].mat = NOTHING;
+ edt[i].salle.building = 'N';
+ edt[i].salle.id = 0;
+ edt[i].length = 1;
+ } else if(to_fill == 1) {
+ edt[i].date.day = buffer;
+ } else if(to_fill == 2) {
+ edt[i].date.month = buffer;
+ } else if(to_fill == 3) {
+ edt[i].date.year = buffer;
+ } else {
+ edt[i].length++;
+ }
+ to_fill++;
+ buffer = 0;
+ if(c == '\n') {
+ i++;
+ to_fill = 0;
+ }
+ }
+ c = fgetc(ptr);
+ }
+
+ fclose(ptr);
+
+ if(!is_sorted(edt, size)) {
+ assert(0);
+ }
+ return edt;
+}
+
+bool str_equal(char* s1, char* s2) {
+ // note : s1 and s2 must be valid strings (aka have \0 at the end)
+ if((int)(s1[0]) == 0 || (int)(s2[0]) == 0) {
+ return ((int)(s1[0]) == 0 && (int)(s2[0]) == 0);
+ } else if(s1[0] != s2[0]) {
+ return false;
+ }
+ return str_equal(&s1[1], &s2[1]);
+}
+
+void str_copy(char* src, int l1, char* dest) {
+ /* put the word src with length l1, \0 NOT included, in dest */
+ for(int i = 0; i <= l1; i++) {
+ dest[i] = src[i];
+ }
+ dest[l1] = '\0';
+}
+
+colleur* import_colleurs(char* filename, int n_colleurs, int max_available) {
+ /*
+
+ file has the following format :
+ name
+ mat
+ dates (date*)
+ -
+ name2
+ mat2
+ dates2
+ -
+ name3
+ ...
+ $
+
+ */
+ FILE* ptr = fopen(filename, "r");
+ char c = fgetc(ptr);
+ // {char* name; int namelen; topic mat; date* disp; int n_disp;}
+ colleur* res = malloc(sizeof(colleur)*n_colleurs);
+
+ char* word = malloc(sizeof(char)*30);
+ int wordlen = 0;
+
+ int buffer = 0;
+
+ int date_ptr = 0;
+
+ int current = 0; // 0 = name, 1 = mat, 2+ = dates
+ int colleur_ptr = 0;
+
+ while(c != EOF && c != '$') {
+ if(c == '\n') {
+ if(current == 0) {
+ word[wordlen] = '\0';
+ res[colleur_ptr].name = malloc(sizeof(char)*30);
+ str_copy(word, wordlen, res[colleur_ptr].name);
+ res[colleur_ptr].namelen = wordlen;
+ res[colleur_ptr].id = colleur_ptr;
+ } else if(current == 1) {
+ if(word[0] == 'M') { // math
+ res[colleur_ptr].mat = MATH;
+ } else if(word[0] == 'P') { // physics
+ res[colleur_ptr].mat = PHYSICS;
+ } else if(word[0] == 'E') { // english
+ res[colleur_ptr].mat = ENGLISH;
+ } else if(word[0] == 'I') { // info
+ res[colleur_ptr].mat = INFO;
+ } else {
+ word[wordlen] = '\0';
+ fatal("Wait that's illegal (%s)", word);
+ assert(0);
+ }
+ res[colleur_ptr].disp = malloc(sizeof(date)*max_available);
+ } else {
+ res[colleur_ptr].disp[current-2].year = buffer;
+ }
+ current++;
+ wordlen = 0;
+ buffer = 0;
+ date_ptr = 0;
+ } else if(c == '+') {
+ res[colleur_ptr].n_disp = current-2;
+ current = 0;
+ colleur_ptr++;
+
+ c = fgetc(ptr); // always a '\n', this to avoid some seg fault
+ } else {
+ if(current <= 1) {
+ word[wordlen] = c;
+ wordlen++;
+ } else {
+ if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer *= 10;
+ buffer += (int)(c) - 48;
+ } else {
+ if(date_ptr == 0) {
+ res[colleur_ptr].disp[current-2].hour = buffer;
+ } else if(date_ptr == 1) {
+ res[colleur_ptr].disp[current-2].day = buffer;
+ } else if(date_ptr == 2) {
+ res[colleur_ptr].disp[current-2].month = buffer;
+ } else {
+ fatal("Oh no (%d)", date_ptr);
+ assert(0);
+ }
+ buffer = 0;
+ date_ptr++;
+ }
+ }
+ }
+ //printf("%c", c);
+ c = fgetc(ptr);
+ }
+ // {char* name; int namelen; topic mat; date* disp; int n_disp;}
+
+ info("Successfully imported colleurs");
+ fclose(ptr);
+ free(word);
+
+ return res;
+}
+
+date increment_date(date d, int inc) {
+ int remaining = inc;
+ date res = d;
+ int delta_day = 0;
+ while(remaining > 0) {
+ res.day++;
+ delta_day = (res.month == 1 || res.month == 3 || res.month == 5 || res.month == 7 || res.month == 8 || res.month == 10 || res.month == 12) - 2*(res.month == 2) + (res.month == 2 && res.year%4 == 0 && res.year%100 != 0);
+ // sweet jesus
+ if(res.day > 30 + delta_day) {
+ res.day = 1;
+ if(res.month == 12) {
+ res.month = 1;
+ res.year++;
+ } else {
+ res.month++;
+ }
+ }
+ remaining--;
+ }
+ return res;
+}
+
+creneau* import_creneaux_oneweek(char* filename, int len_file, int n_weeks, int n_groups) {
+ // import creneau data from a file then copy paste it for specified amount of weeks
+ FILE* ptr = fopen(filename, "r");
+ char c = fgetc(ptr);
+
+ creneau* edt = malloc(sizeof(creneau)*len_file*n_weeks);
+ int i = 0;
+ int to_fill = 0;
+
+ int buffer = 0;
+
+ while(c != EOF && c != '$') {
+ if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer *= 10;
+ buffer += (int)(c) - 48;
+ } else {
+ if(to_fill == 0) {
+ //printf("%d\n", i);
+ edt[i].date.hour = buffer;
+ edt[i].group = 0;
+ edt[i].name = malloc(sizeof(char)*35);
+ edt[i].name[0] = 'n';
+ edt[i].name[1] = 'o';
+ edt[i].name[2] = 'n';
+ edt[i].name[3] = 'e';
+ edt[i].name[4] = '\0';
+ edt[i].namelen = 4;
+ edt[i].mat = NOTHING;
+ edt[i].salle.building = 'N';
+ edt[i].salle.id = 0;
+ edt[i].length = 1;
+ edt[i].allow_grps = malloc(sizeof(bool)*n_groups);
+ for(int ii = 0; ii < n_groups; ii++) {
+ edt[i].allow_grps[ii] = true;
+ }
+ } else if(to_fill == 1) {
+ edt[i].date.day = buffer;
+ } else if(to_fill == 2) {
+ edt[i].date.month = buffer;
+ } else if(to_fill == 3) {
+ edt[i].date.year = buffer;
+ } else {
+ edt[i].length++;
+ }
+ to_fill++;
+ buffer = 0;
+ if(c == '\n') {
+ i++;
+ to_fill = 0;
+ }
+ }
+ c = fgetc(ptr);
+ }
+ fclose(ptr);
+
+ for(int k = 1; k < n_weeks; k++) {
+ for(int i = 0; i < len_file; i++) {
+ edt[k*len_file+i].date = increment_date(edt[i].date, 7*k);
+ edt[k*len_file+i].group = 0;
+ edt[k*len_file+i].name = malloc(sizeof(char)*35);
+ edt[k*len_file+i].name[0] = 'n';
+ edt[k*len_file+i].name[1] = 'o';
+ edt[k*len_file+i].name[2] = 'n';
+ edt[k*len_file+i].name[3] = 'e';
+ edt[k*len_file+i].name[4] = '\0';
+ edt[k*len_file+i].namelen = 4;
+ edt[k*len_file+i].mat = NOTHING;
+ edt[k*len_file+i].salle.building = 'N';
+ edt[k*len_file+i].salle.id = 0;
+ edt[k*len_file+i].length = edt[i].length;
+ edt[k*len_file+i].allow_grps = malloc(sizeof(bool)*n_groups);
+ for(int ii = 0; ii < n_groups; ii++) {
+ edt[k*len_file+i].allow_grps[ii] = true;
+ }
+ }
+ }
+
+ /*for(int k = 0; k < len_file*n_weeks; k++) {
+ printf("%d %d %d %d %d %d\n", edt[k].date.hour, edt[k].date.day, edt[k].date.month, edt[k].date.year, edt[k].group, (int)(edt[k].mat));
+ }*/
+
+ if(!is_sorted(edt, n_weeks*len_file)) {
+ assert(0);
+ }
+ info("Imported creneaux successfully");
+ return edt;
+}
+
+void expand(colleur* guy, int id, int n_weeks) {
+ int len_1st = guy[id].n_disp;
+ date* new = malloc(sizeof(date)*len_1st*n_weeks);
+
+ for(int b = 0; b < len_1st; b++) {
+ new[b] = guy[id].disp[b];
+ }
+ for(int week = 1; week < n_weeks; week++) {
+ for(int i = 0; i < len_1st; i++) {
+ new[week*len_1st+i] = increment_date(guy[id].disp[i], 7*week);
+ }
+ }
+
+ free(guy[id].disp);
+ guy[id].n_disp *= n_weeks;
+ guy[id].disp = new;
+}
+
+colleur* import_colleurs_oneweek(char* filename, int n_colleurs, int n_weeks, int len_oneweek) {
+ // same as before, but each colleur only set his/her creneaux for the 1st week
+ FILE* ptr = fopen(filename, "r");
+ char c = fgetc(ptr);
+ // {char* name; int namelen; topic mat; date* disp; int n_disp;}
+ colleur* res = malloc(sizeof(colleur)*n_colleurs);
+
+ char* word = malloc(sizeof(char)*30);
+ int wordlen = 0;
+
+ int buffer = 0;
+
+ int date_ptr = 0;
+
+ int current = 0; // 0 = name, 1 = mat, 2+ = dates
+ int colleur_ptr = 0;
+
+ while(c != EOF && c != '$') {
+ if(c == '\n') {
+ if(current == 0) {
+ word[wordlen] = '\0';
+ res[colleur_ptr].name = malloc(sizeof(char)*30);
+ str_copy(word, wordlen, res[colleur_ptr].name);
+ res[colleur_ptr].namelen = wordlen;
+ } else if(current == 1) {
+ if(word[0] == 'M') { // math
+ res[colleur_ptr].mat = MATH;
+ //printf("M");
+ } else if(word[0] == 'P') { // physics
+ res[colleur_ptr].mat = PHYSICS;
+ //printf("P");
+ } else if(word[0] == 'E') { // english
+ res[colleur_ptr].mat = ENGLISH;
+ //printf("E");
+ } else if(word[0] == 'I') { // info
+ res[colleur_ptr].mat = INFO;
+ } else {
+ word[wordlen] = '\0';
+ fatal("Wait that's illegal (%s)", word);
+ assert(0);
+ }
+ res[colleur_ptr].disp = malloc(sizeof(date)*len_oneweek);
+ res[colleur_ptr].id = colleur_ptr;
+ } else {
+ res[colleur_ptr].disp[current-2].year = buffer;
+ }
+ current++;
+ wordlen = 0;
+ buffer = 0;
+ date_ptr = 0;
+ } else if(c == '+') {
+ res[colleur_ptr].n_disp = current-2;
+ current = 0;
+ colleur_ptr++;
+
+ c = fgetc(ptr); // always a '\n', this to avoid some seg fault
+ } else {
+ if(current <= 1) {
+ word[wordlen] = c;
+ wordlen++;
+ } else {
+ if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer *= 10;
+ buffer += (int)(c) - 48;
+ } else {
+ if(date_ptr == 0) {
+ res[colleur_ptr].disp[current-2].hour = buffer;
+ } else if(date_ptr == 1) {
+ res[colleur_ptr].disp[current-2].day = buffer;
+ } else if(date_ptr == 2) {
+ res[colleur_ptr].disp[current-2].month = buffer;
+ } else {
+ fatal("Oh no (%d)", date_ptr);
+ assert(0);
+ }
+ buffer = 0;
+ date_ptr++;
+ }
+ }
+ }
+ //printf("%c", c);
+ c = fgetc(ptr);
+ }
+ // {char* name; int namelen; topic mat; date* disp; int n_disp;}
+
+ for(int c = 0; c < n_colleurs; c++) {
+ expand(res, c, n_weeks);
+ }
+
+ fclose(ptr);
+ free(word);
+
+ info("Imported colleurs with no problems");
+ return res;
+}
+
+int str_to_int(char* s) {
+ char c = 'e';
+ int i = 0;
+ int buffer = 0;
+ while(c != '\0') {
+ c = s[i];
+ buffer *= 10;
+ if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer += (int)(c)-48;
+ }
+ i++;
+ }
+ return buffer/10;
+}
+
+bool equal_d(date d1, date d2) {
+ return (d1.hour == d2.hour && d2.day == d1.day && d1.month == d2.month && d1.year == d2.year);
+}
+
+int locate_date(creneau* edt, int len_edt, date d) {
+ int i = 0;
+ while(i < len_edt && !equal_d(edt[i].date, d)) {
+ i++;
+ }
+
+ if(i == len_edt) {
+ return -1;
+ }
+ return i;
+}
+
+void import_tds(creneau* edt, int len_edt, int len_oneweek, char* filename) {
+ FILE* ptr = fopen(filename, "r");
+ char c = fgetc(ptr);
+ int edtptr = 0;
+
+ int current = 0;
+ int place = 0;
+
+ char method;
+
+ int buffer = 0;
+
+ date d;
+
+ while(c != EOF && c != '$') {
+ //printf("%c", c);
+ if(c == '+') {
+ current = 0;
+ place = 0;
+ buffer = 0;
+ c = fgetc(ptr); // always a \n
+ } else if(c == '\n' && current != 0) {
+ if(current == 1) {
+ edtptr = locate_date(edt, len_edt, d);
+ } else {
+ if(method == 'A') {
+ int k = 0;
+ int os = 1;
+ while(edtptr + k*len_oneweek >= 0 && edtptr + k*len_oneweek < len_edt) {
+ //info("[%d, %d]", buffer, edtptr + k*len_oneweek);
+ //usleep(1000000);
+ edt[edtptr + k*len_oneweek].allow_grps[buffer-1] = false;
+ while(equal_d(edt[edtptr + k*len_oneweek].date, edt[edtptr + k*len_oneweek + os].date)) {
+ //info("[%d, %d]", buffer, edtptr + k*len_oneweek + os);
+ edt[edtptr + k*len_oneweek + os].allow_grps[buffer-1] = false;
+ os++;
+ }
+ k++;
+ os = 1;
+ }
+ } else {
+ fatal("Unknown method %d. Check if the method used is valid, or ask a dev to fix it ", method);
+ exit(1);
+ }
+ }
+ current++;
+ buffer = 0;
+ } else if((c == '\n' && current == 0) || c == ' ') {
+ if(place == 0) {
+ d.hour = buffer;
+ } else if(place == 1) {
+ d.day = buffer;
+ } else if(place == 2) {
+ d.month = buffer;
+ } else {
+ d.year = buffer;
+ current = 1;
+ }
+ place++;
+ buffer = 0;
+ } else if((int)(c) >= 48 && (int)(c) <= 57) {
+ buffer *= 10;
+ buffer += (int)(c) - 48;
+ } else if(current == 1) {
+ method = c;
+ }
+ c = fgetc(ptr);
+ }
+ fclose(ptr);
+
+ info("Imported special creneaux successfully");
+}
\ No newline at end of file