static void surface_optimize (GtsSurface * surface,
gdouble max_cost)
{
GtsEHeap * heap;
GtsEdge * e;
gdouble top_cost;
heap = gts_eheap_new ((GtsKeyFunc) edge_swap_cost, NULL);
gts_eheap_freeze (heap);
gts_surface_foreach_edge (surface, (GtsFunc) create_heap_optimize, heap);
gts_eheap_thaw (heap);
gts_allow_floating_edges = TRUE;
while ((e = gts_eheap_remove_top (heap, &top_cost)) &&
top_cost < max_cost)
edge_swap (e, surface, heap);
gts_allow_floating_edges = FALSE;
if (e) GTS_OBJECT (e)->reserved = NULL;
gts_eheap_foreach (heap, (GFunc) gts_object_reset_reserved, NULL);
gts_eheap_destroy (heap);
}
/**
* gts_eheap_update:
* @heap: a #GtsEHeap.
*
* Updates the key of each element of @heap and reorders it.
*/
void gts_eheap_update (GtsEHeap * heap)
{
guint i, len;
GtsEHeapPair ** pairs;
gpointer data;
GtsKeyFunc func;
g_return_if_fail (heap != NULL);
g_return_if_fail (heap->func != NULL);
heap->frozen = TRUE;
len = heap->elts->len;
pairs = (GtsEHeapPair **) heap->elts->pdata;
data = heap->data;
func = heap->func;
for (i = 0; i < len; i++) {
GtsEHeapPair * pair = pairs[i];
pair->key = (*func) (pair->data, data);
}
gts_eheap_thaw (heap);
}
/**
* gts_graph_bisection_bkl_refine:
* @bg: a #GtsGraphBisection.
* @mmax: the maximum number of unsuccessful successive moves.
* @imbalance: the maximum relative imbalance allowed between the
* weights of both halves of the partition.
*
* An implementation of the simplified boundary Kernighan-Lin
* algorithm for graph bisection refinement as described in Karypis
* and Kumar (1997).
*
* The algorithm stops if @mmax consecutive modes do not lead to a
* decrease in the number of edges cut. This last @mmax moves are
* undone.
*
* Returns: the decrease in the weight of the edges cut by the bisection.
*/
gdouble gts_graph_bisection_bkl_refine (GtsGraphBisection * bg,
guint mmax,
gfloat imbalance)
{
GtsEHeap * h1, * h2;
GtsGNode * n;
guint nm = 0, i;
GtsGNode ** moves;
gdouble bestcost = 0., totalcost = 0., best_balance;
gboolean balanced = FALSE;
g_return_val_if_fail (bg != NULL, 0.);
g_return_val_if_fail (mmax > 0, 0.);
g_return_val_if_fail (imbalance >= 0. && imbalance <= 1., 0.);
h1 = gts_eheap_new ((GtsKeyFunc) node_move_cost1, bg);
gts_eheap_freeze (h1);
g_hash_table_foreach (bg->bg1, (GHFunc) build_bheap, h1);
gts_eheap_thaw (h1);
h2 = gts_eheap_new ((GtsKeyFunc) node_move_cost2, bg);
gts_eheap_freeze (h2);
g_hash_table_foreach (bg->bg2, (GHFunc) build_bheap, h2);
gts_eheap_thaw (h2);
moves = g_malloc (sizeof (GtsGNode *)*mmax);
imbalance *= gts_graph_weight (bg->g);
best_balance = fabs (gts_graph_weight (bg->g1) - gts_graph_weight (bg->g2));
if (best_balance <= imbalance)
balanced = TRUE;
do {
GtsGraph * g1, * g2;
GHashTable * bg1, * bg2;
gdouble cost;
if (gts_graph_weight (bg->g1) > gts_graph_weight (bg->g2)) {
n = gts_eheap_remove_top (h1, &cost);
g1 = bg->g1;
g2 = bg->g2;
bg1 = bg->bg1;
bg2 = bg->bg2;
}
else {
n = gts_eheap_remove_top (h2, &cost);
g1 = bg->g2;
g2 = bg->g1;
bg1 = bg->bg2;
bg2 = bg->bg1;
}
if (n) {
gdouble balance;
GTS_OBJECT (n)->reserved = n;
gts_container_add (GTS_CONTAINER (g2), GTS_CONTAINEE (n));
gts_container_remove (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
g_hash_table_remove (bg1, n);
if (gts_gnode_degree (n, g1))
g_hash_table_insert (bg2, n, n);
update_neighbors (n, bg, h1, h2);
totalcost += cost;
balance = fabs (gts_graph_weight (g1) - gts_graph_weight (g2));
if (!balanced && balance <= imbalance) {
bestcost = totalcost;
best_balance = balance;
balanced = TRUE;
nm = 0;
}
else if (totalcost < bestcost &&
(balance < best_balance || balance <= imbalance)) {
bestcost = totalcost;
best_balance = balance;
nm = 0;
}
else if (totalcost == bestcost && balance < best_balance) {
best_balance = balance;
nm = 0;
}
else
moves[nm++] = n;
}
} while (n && nm < mmax);
gts_container_foreach (GTS_CONTAINER (bg->g),
(GtsFunc) gts_object_reset_reserved, NULL);
gts_eheap_destroy (h1);
gts_eheap_destroy (h2);
/* undo last nm moves */
for (i = 0; i < nm; i++) {
GtsGNode * n = moves[i];
GtsGraph * g1, * g2;
GHashTable * bg1, * bg2;
if (gts_containee_is_contained (GTS_CONTAINEE (n),
GTS_CONTAINER (bg->g1))) {
g1 = bg->g1;
g2 = bg->g2;
bg1 = bg->bg1;
bg2 = bg->bg2;
}
else {
g1 = bg->g2;
g2 = bg->g1;
bg1 = bg->bg2;
bg2 = bg->bg1;
}
gts_container_add (GTS_CONTAINER (g2), GTS_CONTAINEE (n));
gts_container_remove (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
g_hash_table_remove (bg1, n);
if (gts_gnode_degree (n, g1))
g_hash_table_insert (bg2, n, n);
update_neighbors (n, bg, NULL, NULL);
}
g_free (moves);
return bestcost;
}
/**
* gts_graph_bisection_kl_refine:
* @bg: a #GtsGraphBisection.
* @mmax: the maximum number of unsuccessful successive moves.
*
* An implementation of the simplified Kernighan-Lin algorithm for
* graph bisection refinement as described in Karypis and Kumar
* (1997).
*
* The algorithm stops if @mmax consecutive modes do not lead to a
* decrease in the number of edges cut. This last @mmax moves are
* undone.
*
* Returns: the decrease in the weight of the edges cut by the bisection.
*/
gdouble gts_graph_bisection_kl_refine (GtsGraphBisection * bg,
guint mmax)
{
GtsEHeap * h1, * h2;
GtsGNode * n;
guint nm = 0, i;
GtsGNode ** moves;
gdouble bestcost = 0., totalcost = 0., best_balance;
g_return_val_if_fail (bg != NULL, 0.);
g_return_val_if_fail (mmax > 0, 0.);
h1 = gts_eheap_new ((GtsKeyFunc) node_move_cost1, bg);
gts_eheap_freeze (h1);
gts_container_foreach (GTS_CONTAINER (bg->g1), (GtsFunc) build_heap, h1);
gts_eheap_thaw (h1);
h2 = gts_eheap_new ((GtsKeyFunc) node_move_cost2, bg);
gts_eheap_freeze (h2);
gts_container_foreach (GTS_CONTAINER (bg->g2), (GtsFunc) build_heap, h2);
gts_eheap_thaw (h2);
moves = g_malloc (sizeof (GtsGNode *)*mmax);
best_balance = fabs (gts_graph_weight (bg->g1) - gts_graph_weight (bg->g2));
do {
GtsGraph * g1, * g2;
gdouble cost;
if (gts_graph_weight (bg->g1) > gts_graph_weight (bg->g2)) {
n = gts_eheap_remove_top (h1, &cost);
g1 = bg->g1;
g2 = bg->g2;
}
else {
n = gts_eheap_remove_top (h2, &cost);
g1 = bg->g2;
g2 = bg->g1;
}
if (n) {
GSList * i;
GTS_OBJECT (n)->reserved = NULL;
gts_container_add (GTS_CONTAINER (g2), GTS_CONTAINEE (n));
gts_container_remove (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
totalcost += cost;
if (totalcost < bestcost) {
bestcost = totalcost;
nm = 0;
}
else if (totalcost == bestcost) {
gdouble balance = fabs (gts_graph_weight (g1) - gts_graph_weight (g2));
if (balance < best_balance) {
best_balance = balance;
nm = 0;
}
}
else
moves[nm++] = n;
i = GTS_SLIST_CONTAINER (n)->items;
while (i) {
GtsGNode * n1 = GTS_GNODE_NEIGHBOR (n, i->data);
if (GTS_OBJECT (n1)->reserved &&
gts_containee_is_contained (GTS_CONTAINEE (n1),
GTS_CONTAINER (bg->g))) {
GtsEHeap * h =
gts_containee_is_contained (GTS_CONTAINEE (n1),
GTS_CONTAINER (bg->g1)) ? h1 : h2;
gts_eheap_remove (h, GTS_OBJECT (n1)->reserved);
GTS_OBJECT (n1)->reserved = gts_eheap_insert (h, n1);
}
i = i->next;
}
}
} while (n && nm < mmax);
gts_eheap_foreach (h1, (GFunc) gts_object_reset_reserved, NULL);
gts_eheap_foreach (h2, (GFunc) gts_object_reset_reserved, NULL);
gts_eheap_destroy (h1);
gts_eheap_destroy (h2);
/* undo last nm moves */
for (i = 0; i < nm; i++) {
GtsGNode * n = moves[i];
GtsGraph * g1 =
gts_containee_is_contained (GTS_CONTAINEE (n),
GTS_CONTAINER (bg->g1)) ? bg->g1 : bg->g2;
GtsGraph * g2 = g1 == bg->g1 ? bg->g2 : bg->g1;
gts_container_add (GTS_CONTAINER (g2), GTS_CONTAINEE (n));
gts_container_remove (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
}
g_free (moves);
return bestcost;
}
/**
* gts_graph_bfgg_bisection:
* @g: a #GtsGraph.
* @ntry: the number of randomly selected initial seeds.
*
* An implementation of a "Breadth-First Graph Growing" algorithm.
*
* @ntry randomly chosen seeds are used and the best partition is retained.
*
* Returns: a new #GtsGraphBisection of @g.
*/
GtsGraphBisection * gts_graph_bfgg_bisection (GtsGraph * g, guint ntry)
{
gfloat size, bestcost = G_MAXFLOAT, smin;
GtsGraph * bestg1 = NULL, * bestg2 = NULL;
GtsEHeap * degree_heap;
GtsGNode * seed;
GtsGraphBisection * bg;
g_return_val_if_fail (g != NULL, NULL);
bg = g_malloc (sizeof (GtsGraphBisection));
bg->g = g;
size = gts_graph_weight (g)/2.;
smin = 0.9*size;
degree_heap = gts_eheap_new ((GtsKeyFunc) degree_cost, g);
gts_eheap_freeze (degree_heap);
gts_container_foreach (GTS_CONTAINER (g), (GtsFunc) add_seed, degree_heap);
gts_eheap_thaw (degree_heap);
while (ntry && ((seed = gts_eheap_remove_top (degree_heap, NULL)))) {
GtsGraph * g1, * g2;
GtsGNode * n;
gdouble cost;
GtsGraphTraverse * t = gts_graph_traverse_new (g, seed,
GTS_BREADTH_FIRST, TRUE);
g1 = gts_graph_new (GTS_GRAPH_CLASS (GTS_OBJECT (g)->klass),
g->node_class, g->edge_class);
g2 = gts_graph_new (GTS_GRAPH_CLASS (GTS_OBJECT (g)->klass),
g->node_class, g->edge_class);
while ((n = gts_graph_traverse_next (t)))
if (gts_graph_weight (g1) + gts_gnode_weight (n) <= size) {
gts_container_add (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
GTS_OBJECT (n)->reserved = n;
}
gts_graph_traverse_destroy (t);
gts_container_foreach (GTS_CONTAINER (g), (GtsFunc) add_unused, g2);
cost = gts_graph_edges_cut_weight (g1);
if (!bestg1 || (cost < bestcost && gts_graph_weight (g1) >= smin)) {
if (bestg1)
bestcost = cost;
if (bestg1)
gts_object_destroy (GTS_OBJECT (bestg1));
if (bestg2)
gts_object_destroy (GTS_OBJECT (bestg2));
bestg1 = g1;
bestg2 = g2;
}
else {
gts_object_destroy (GTS_OBJECT (g1));
gts_object_destroy (GTS_OBJECT (g2));
}
ntry--;
}
gts_eheap_destroy (degree_heap);
#ifdef DEBUG
fprintf (stderr, "bestcost: %5g g1: %5g|%5d g2: %5g|%5d\n",
bestcost,
gts_graph_weight (bestg1),
gts_container_size (GTS_CONTAINER (bestg1)),
gts_graph_weight (bestg2),
gts_container_size (GTS_CONTAINER (bestg2)));
#endif
bg->g1 = bestg1;
bg->g2 = bestg2;
/* boundary nodes */
bg->bg1 = g_hash_table_new (NULL, NULL);
gts_container_foreach (GTS_CONTAINER (bg->g1), (GtsFunc) boundary_node1, bg);
bg->bg2 = g_hash_table_new (NULL, NULL);
gts_container_foreach (GTS_CONTAINER (bg->g2), (GtsFunc) boundary_node2, bg);
return bg;
}
/**
* gts_graph_ggg_bisection:
* @g: a #GtsGraph.
* @ntry: the number of randomly selected initial seeds.
*
* An implementation of the "Greedy Graph Growing" algorithm of
* Karypis and Kumar (1997).
*
* @ntry randomly chosen seeds are used and the best partition is retained.
*
* Returns: a new #GtsGraphBisection of @g.
*/
GtsGraphBisection * gts_graph_ggg_bisection (GtsGraph * g, guint ntry)
{
gfloat size, bestcost = G_MAXFLOAT, smin;
GtsGraph * bestg1 = NULL, * bestg2 = NULL;
gboolean balanced = FALSE;
GtsEHeap * degree_heap;
GtsGNode * seed;
GtsGraphBisection * bg;
g_return_val_if_fail (g != NULL, NULL);
bg = g_malloc (sizeof (GtsGraphBisection));
bg->g = g;
size = gts_graph_weight (g)/2.;
smin = 0.9*size;
degree_heap = gts_eheap_new ((GtsKeyFunc) degree_cost, g);
gts_eheap_freeze (degree_heap);
gts_container_foreach (GTS_CONTAINER (g), (GtsFunc) add_seed, degree_heap);
gts_eheap_thaw (degree_heap);
while (ntry && ((seed = gts_eheap_remove_top (degree_heap, NULL)))) {
GtsGraph * g1, * g2;
GtsGNode * n;
gdouble cost;
gpointer data[2];
GtsEHeap * heap;
g1 = gts_graph_new (GTS_GRAPH_CLASS (GTS_OBJECT (g)->klass),
g->node_class, g->edge_class);
g2 = gts_graph_new (GTS_GRAPH_CLASS (GTS_OBJECT (g)->klass),
g->node_class, g->edge_class);
data[0] = g;
data[1] = g1;
heap = gts_eheap_new ((GtsKeyFunc) node_cost, data);
gts_container_add (GTS_CONTAINER (g1), GTS_CONTAINEE (seed));
GTS_OBJECT (seed)->reserved = seed;
gts_gnode_foreach_neighbor (seed, g, (GtsFunc) add_neighbor, heap);
while ((n = gts_eheap_remove_top (heap, &cost)))
if (gts_graph_weight (g1) + gts_gnode_weight (n) <= size) {
gts_container_add (GTS_CONTAINER (g1), GTS_CONTAINEE (n));
GTS_OBJECT (n)->reserved = n;
gts_gnode_foreach_neighbor (n, g, (GtsFunc) add_neighbor, heap);
}
else
GTS_OBJECT (n)->reserved = NULL;
gts_eheap_destroy (heap);
gts_container_foreach (GTS_CONTAINER (g), (GtsFunc) add_unused, g2);
cost = gts_graph_edges_cut_weight (g1);
if (!bestg1 ||
(!balanced && gts_graph_weight (g1) >= smin) ||
(cost < bestcost && gts_graph_weight (g1) >= smin)) {
if (bestg1)
bestcost = cost;
if (bestg1)
gts_object_destroy (GTS_OBJECT (bestg1));
if (bestg2)
gts_object_destroy (GTS_OBJECT (bestg2));
bestg1 = g1;
bestg2 = g2;
if (gts_graph_weight (g1) >= smin)
balanced = TRUE;
}
else {
gts_object_destroy (GTS_OBJECT (g1));
gts_object_destroy (GTS_OBJECT (g2));
}
ntry--;
}
gts_eheap_destroy (degree_heap);
#ifdef DEBUG
fprintf (stderr, "bestcost: %5g g1: %5g|%5d g2: %5g|%5d\n",
bestcost,
gts_graph_weight (bestg1),
gts_container_size (GTS_CONTAINER (bestg1)),
gts_graph_weight (bestg2),
gts_container_size (GTS_CONTAINER (bestg2)));
#endif
g_assert (bestg1 != NULL);
bg->g1 = bestg1;
g_assert (bestg2 != NULL);
bg->g2 = bestg2;
/* boundary nodes */
bg->bg1 = g_hash_table_new (NULL, NULL);
gts_container_foreach (GTS_CONTAINER (bg->g1), (GtsFunc) boundary_node1, bg);
bg->bg2 = g_hash_table_new (NULL, NULL);
gts_container_foreach (GTS_CONTAINER (bg->g2), (GtsFunc) boundary_node2, bg);
return bg;
}
