constraint::constraint(sudoku& puzzle) : n(puzzle.getN()), p(puzzle.getP()), q(puzzle.getQ())
{
rows_init(puzzle);
setColumns();
setBlocks();
domain_init();
if(tokenReader::lcv) {
lcv_init();
}
if(tokenReader::dh) {
dh_init();
}
if(tokenReader::mrv) {
mrv_init();
}
solution_init();
}
solution *new_sol_init(int nmachines, int vcount) {
int val = 0;
solution *sol = (solution *) NULL;
sol = CC_SAFE_MALLOC(1, solution);
CCcheck_NULL_2(sol, "Failed to allocate memory")
solution_init(sol);
val = solution_alloc(sol, nmachines, vcount);
CCcheck_val_2(val, "Failed in solution_alloc");
CLEAN:
if (val) {
solution_free(sol);
CC_IFFREE(sol, solution);
}
return sol;
}
int combinePathRelinking(SS *scatter_search, GPtrArray *array, int *subsetsol,
int *found) {
int i, val = 0;
int njobs = scatter_search->njobs;
int nmachines = scatter_search->nmachines;
int dist = 0;
int counter = 0;
Job **jobarray = scatter_search->jobarray;
REFSET *refset = scatter_search->rs;
GList *list = (GList *) NULL;
GList *it = (GList *) NULL;
GList *pool = (GList *) NULL;
solution *prev = (solution *) NULL;
solution sol_g;
solution sol_c;
solution *sol1 = (solution *)g_ptr_array_index(array, subsetsol[1] - 1);
solution *sol2 = (solution *)g_ptr_array_index(array, subsetsol[2] - 1);
if (sol1->totalweightcomptime < sol2->totalweightcomptime) {
val = solution_copy(&sol_g, *sol1);
val = solution_copy(&sol_c, *sol2);
} else {
val = solution_copy(&sol_c, *sol1);
val = solution_copy(&sol_g, *sol2);
}
for (i = 0; i < njobs; ++i) {
partlist *temp1 = sol_g.vlist[i].part;
partlist *temp2 = sol_c.vlist[i].part;
if (temp1->key != temp2->key) {
dist++;
list = g_list_append(list, jobarray[i]);
}
}
prev = &(sol_c);
while (dist > 0) {
Job *minjob = (Job *) NULL;
partlist *minmach = (partlist *) NULL;
solution *sol = CC_SAFE_MALLOC(1, solution);
solution_init(sol);
solution_alloc(sol, nmachines, njobs);
solution_update(sol, *prev);
int max = INT_MIN;
int temp;
for (it = list; it; it = it->next) {
Job *j = (Job *)it->data;
partlist *mach_c = sol->vlist[j->job].part;
partlist *mach_g = sol->part + sol_g.vlist[j->job].part->key;
temp = moveSS(j, mach_c, mach_g);
if (temp > max) {
minjob = j;
minmach = mach_g;
max = temp;
}
}
partlist_move_order(minmach, sol->vlist, minjob, njobs);
sol->totalweightcomptime -= max;
pool = g_list_append(pool, sol);
list = g_list_remove(list, minjob);
dist--;
prev = sol;
}
counter = 0;
GList *l = pool;
while (l != NULL) {
GList *next = l->next;
if (counter % 10 == 0) {
solution *sol = (solution *)l->data;
localsearch_wrap(sol, scatter_search->lowerbound, 0);
solution_unique(sol);
} else {
solution *sol = (solution *)l->data;
solution_free(sol);
CC_IFFREE(sol, solution);
pool = g_list_delete_link(pool, l);
}
counter++;
l = next;
}
l = pool;
while (l != NULL) {
solution *last1 = (solution *) g_ptr_array_index(refset->list1,
refset->list1->len - 1);
solution *last2 = (solution *) g_ptr_array_index(refset->list2, 0);
GList *next = l->next;
solution *new_sol = (solution *)l->data;
int not_in_refset = !solution_in_refset(scatter_search, new_sol);
if (new_sol->totalweightcomptime < last1->totalweightcomptime &&
not_in_refset) {
new_sol->dist = 0;
refset->newsol = 1;
new_sol->iter = scatter_search->iter + 1;
g_ptr_array_remove(refset->list1, last1);
g_ptr_array_remove(array, last1);
g_ptr_array_add(refset->list1, new_sol);
g_ptr_array_add(array, new_sol);
g_ptr_array_sort(refset->list1, order_totalweightcomptime);
g_ptr_array_sort(array, order_totalweightcomptime);
solution_free(last1);
CC_IFFREE(last1, solution);
*found = 1;
} else if (not_in_refset) {
SSrefset_distance(scatter_search, new_sol);
if (new_sol->dist > last2->dist) {
refset->newsol = 1;
new_sol->iter = scatter_search->iter + 1;
g_ptr_array_remove(refset->list2, last2);
g_ptr_array_remove(array, last2);
g_ptr_array_add(refset->list2, new_sol);
g_ptr_array_add(array, new_sol);
g_ptr_array_sort(refset->list2, order_distance);
g_ptr_array_sort(array, order_distance);
solution_free(last2);
CC_IFFREE(last2, solution);
*found = 1;
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
pool = g_list_delete_link(pool, l);
l = next;
}
g_list_free(pool);
solution_free(&sol_g);
solution_free(&sol_c);
return val;
}
int SSrun_scatter_search(SS *scatter_search, CCutil_timer *timer) {
guint i;
REFSET *refset = scatter_search->rs;
int flag, val = 0;
int nbnew_sol = 0;
int nbjobs = scatter_search->njobs;
int nmachines = scatter_search->nmachines;
int nb_noimprovements = 0;
int *totsubset = (int *) NULL;
double limit = scatter_search->timelimit;
totsubset = CC_SAFE_MALLOC(scatter_search->b1 + 1, int);
CCcheck_NULL_2(totsubset, "Failed tot allocate memory to tot subset");
if (refset->list1->len == 0) {
printf("We can't run scatter search, refset is empty\n");
val = 1;
goto CLEAN;
}
printf("PMCombination method\n");
CCutil_suspend_timer(timer);
CCutil_resume_timer(timer);
while (refset->newsol && scatter_search->status != opt &&
timer->cum_zeit < limit) {
GPtrArray *list = g_ptr_array_new();
for (i = 0; i < refset->list1->len; ++i) {
g_ptr_array_add(list, g_ptr_array_index(refset->list1, i));
}
for (i = 0; i < refset->list2->len; ++i) {
g_ptr_array_add(list, g_ptr_array_index(refset->list2, i));
}
compute_fitness(scatter_search);
refset->newsol = 0;
if (scatter_search->iter > 0) {
int best = scatter_search->upperbound;
CCutil_suspend_timer(timer);
CCutil_resume_timer(timer);
double rel_error = ((double)best - (double)scatter_search->lowerbound) /
(double)scatter_search->lowerbound;
printf("iteration %d with best wct %d and rel error %f, number of new solutions %d, time = %f\n",
scatter_search->iter, best, rel_error, nbnew_sol, timer->cum_zeit);
}
nbnew_sol = 0;
k_subset_init(list->len, 2, totsubset, &flag);
while (flag && scatter_search->status != opt) {
solution *new_sol = CC_SAFE_MALLOC(1, solution);
solution_init(new_sol);
solution_alloc(new_sol, nmachines, nbjobs);
int rval = 1;
rval = combine_PM(scatter_search, list, totsubset, 2, new_sol);
if (!rval) {
solution_calc(new_sol, *(scatter_search->jobarray));
new_sol->iter = scatter_search->iter + 1;
localsearch_random_k(new_sol, scatter_search->lowerbound, 2);
solution_unique(new_sol);
if (!dynamic_update(scatter_search, list, new_sol)) {
if (new_sol->totalweightcomptime < scatter_search->upperbound) {
scatter_search->upperbound = new_sol->totalweightcomptime;
}
if (new_sol->totalweightcomptime == scatter_search->lowerbound) {
scatter_search->status = opt;
printf("Found optimal with SS with subset generation 1\n");
}
nbnew_sol++;
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
k_subset_lex_successor(list->len, 2, totsubset, &flag);
}
k_subset_init(list->len, 3, totsubset, &flag);
solution *sol = (solution *)NULL;
sol = (solution *) g_ptr_array_index(list, 0);
while (flag && scatter_search->status != opt) {
solution *new_sol = CC_SAFE_MALLOC(1, solution);
solution_init(new_sol);
solution_alloc(new_sol, nmachines, nbjobs);
int rval = 1;
rval = combine_PM(scatter_search, list, totsubset, 3,
new_sol); //Dell'Amico et al.
if (!rval) {
solution_calc(new_sol, *(scatter_search->jobarray));
new_sol->iter = scatter_search->iter + 1;
localsearch_random_k(new_sol, scatter_search->lowerbound, 2);
solution_unique(new_sol);
if (!dynamic_update(scatter_search, list, new_sol)) {
if (new_sol->totalweightcomptime < scatter_search->upperbound) {
scatter_search->upperbound = new_sol->totalweightcomptime;
}
if (new_sol->totalweightcomptime == scatter_search->lowerbound) {
scatter_search->status = opt;
printf("Found optimal with SS\n");
}
nbnew_sol++;
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
k_subset_lex_successor(list->len, 3, totsubset, &flag);
sol = (solution *) g_ptr_array_index(list, totsubset[1] - 1);
}
k_subset_init(list->len, 4, totsubset, &flag);
sol = (solution *) g_ptr_array_index(list, 0);
solution *temp_sol = (solution *) g_ptr_array_index(list, 1);
while (flag && scatter_search->status != opt
&& sol->totalweightcomptime <= scatter_search->upperbound
&& temp_sol->totalweightcomptime <= scatter_search->upperbound) {
solution *new_sol = CC_SAFE_MALLOC(1, solution);
solution_init(new_sol);
solution_alloc(new_sol, nmachines, nbjobs);
int rval = 1;
rval = combine_PM(scatter_search, list, totsubset, 4, new_sol);
if (!rval) {
solution_calc(new_sol, *(scatter_search->jobarray));
new_sol->iter = scatter_search->iter + 1;
localsearch_random_k(new_sol, scatter_search->lowerbound, 2);
solution_unique(new_sol);
if (!dynamic_update(scatter_search, list, new_sol)) {
if (new_sol->totalweightcomptime < scatter_search->upperbound) {
scatter_search->upperbound = new_sol->totalweightcomptime;
}
if (new_sol->totalweightcomptime == scatter_search->lowerbound) {
scatter_search->status = opt;
printf("Found optimal with SS\n");
}
nbnew_sol++;
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
k_subset_lex_successor(list->len, 4, totsubset, &flag);
sol = (solution *) g_ptr_array_index(list, totsubset[1] - 1);
temp_sol = (solution *)g_ptr_array_index(list, totsubset[2] - 1);
}
for (i = 0; i < refset->list2->len + 1; ++i) {
totsubset[i] = i;
}
for (i = 5; i < refset->list2->len + 1
&& scatter_search->status != opt; i++) {
solution *new_sol = CC_SAFE_MALLOC(1, solution);
solution_init(new_sol);
solution_alloc(new_sol, nmachines, nbjobs);
int rval = 1;
rval = combine_PM(scatter_search, list, totsubset, i, new_sol);
if (!rval) {
solution_calc(new_sol, *(scatter_search->jobarray));
new_sol->iter = scatter_search->iter + 1;
localsearch_random_k(new_sol, scatter_search->lowerbound, 2);
solution_unique(new_sol);
if (!dynamic_update(scatter_search, list, new_sol)) {
if (new_sol->totalweightcomptime < scatter_search->upperbound) {
scatter_search->upperbound = new_sol->totalweightcomptime;
}
if (new_sol->totalweightcomptime == scatter_search->lowerbound) {
scatter_search->status = opt;
printf("Found optimal with SS\n");
}
nbnew_sol++;
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
} else {
solution_free(new_sol);
CC_IFFREE(new_sol, solution);
}
}
scatter_search->iter++;
if (nbnew_sol == 0) {
nb_noimprovements++;
}
if (refset->newsol == 0 && scatter_search->iter < 10
&& nb_noimprovements < 5) {
add_solution_refset(scatter_search);
refset->newsol = 1;
}
g_ptr_array_free(list, TRUE);
}
CLEAN:
CC_IFFREE(totsubset, int);
return val;
}
