- implemented infinity propagation

- simplify edges only if they are correct connected, so if a (RI) reduction creates an infinity entry the removed edge are not simplified again

[r22536]

diff --git a/heuristical.c b/heuristical.c
index 8b1e142..40a2c97 100644 (file)
--- a/heuristical.c
+++ b/heuristical.c
@@ -17,6 +17,19 @@ static pbqp_node **node_buckets[4];
 static pbqp_node **reduced_bucket = NULL;
 static int         buckets_filled = 0;
 
+static void insert_into_edge_bucket(pbqp_edge *edge)
+{
+       unsigned bucket_len = ARR_LEN(edge_bucket);
+
+       if (edge->bucket_index < bucket_len && edge_bucket[edge->bucket_index]
+                       == edge)
+               /* Edge is already inserted. */
+               return;
+
+       edge->bucket_index = bucket_len;
+       ARR_APP1(pbqp_edge *, edge_bucket, edge);
+}
+
 static void init_buckets(void)
 {
        int i;
@@ -117,7 +130,9 @@ static void normalize_towards_source(pbqp *pbqp, pbqp_edge *edge)
                        src_vec->entries[src_index].data = pbqp_add(
                                        src_vec->entries[src_index].data, min);
 
-                       // TODO add to edge_list if inf
+                       if (min == INF_COSTS) {
+                               insert_into_edge_bucket(edge);
+                       }
                }
        }
 }
@@ -162,7 +177,9 @@ static void normalize_towards_target(pbqp *pbqp, pbqp_edge *edge)
                        tgt_vec->entries[tgt_index].data = pbqp_add(
                                        tgt_vec->entries[tgt_index].data, min);
 
-                       // TODO add to edge_list if inf
+                       if (min == INF_COSTS) {
+                               insert_into_edge_bucket(edge);
+                       }
                }
        }
 }
@@ -191,6 +208,8 @@ static void reorder_node(pbqp_node *node)
        old_bucket_len   = ARR_LEN(old_bucket);
        old_bucket_index = node->bucket_index;
 
+       unsigned test = ARR_LEN(node_buckets[arity]);
+
        if (old_bucket_len <= old_bucket_index ||
            old_bucket[old_bucket_index] != node) {
                /* Old arity is new arity, so we have nothing to do. */
@@ -230,6 +249,10 @@ static void simplify_edge(pbqp *pbqp, pbqp_edge *edge)
        assert(src_node);
        assert(tgt_node);
 
+       /* If edge are already deleted, we have nothing to do. */
+       if (!is_connected(src_node, edge) || !is_connected(tgt_node, edge))
+               return;
+
        if (pbqp->dump_file) {
                char txt[100];
                sprintf(txt, "Simplification of Edge n%d-n%d", src_node->index, tgt_node->index);
@@ -316,7 +339,7 @@ void solve_pbqp_heuristical(pbqp *pbqp)
 
        for (;;) {
                if (ARR_LEN(edge_bucket) > 0) {
-                       panic("Please implement edge simplification");
+                       apply_edge(pbqp);
                } else if (ARR_LEN(node_buckets[1]) > 0) {
                        apply_RI(pbqp);
                } else if (ARR_LEN(node_buckets[2]) > 0) {
@@ -376,6 +399,16 @@ void solve_pbqp_heuristical(pbqp *pbqp)
        free_buckets();
 }
 
+void apply_edge(pbqp *pbqp)
+{
+       unsigned   bucket_len = ARR_LEN(edge_bucket);
+       pbqp_edge *edge       = edge_bucket[bucket_len - 1];
+
+       ARR_SHRINKLEN(edge_bucket, (int)bucket_len - 1);
+
+       simplify_edge(pbqp, edge);
+}
+
 void apply_RI(pbqp *pbqp)
 {
        pbqp_node  **bucket     = node_buckets[1];
@@ -620,7 +653,7 @@ void apply_RN(pbqp *pbqp)
 
        /* Add all incident edges to edge bucket, since they are now independent. */
        for (edge_index = 0; edge_index < edge_len; ++edge_index) {
-               ARR_APP1(pbqp_edge *, edge_bucket, node->edges[node_index]);
+               insert_into_edge_bucket(node->edges[node_index]);
        }
 }
 

diff --git a/heuristical.h b/heuristical.h
index 4d3a556..c461f59 100644 (file)
--- a/heuristical.h
+++ b/heuristical.h
@@ -5,6 +5,8 @@
 
 void solve_pbqp_heuristical(pbqp *pbqp);
 
+void apply_edge(pbqp *pbqp);
+
 void apply_RI(pbqp *pbqp);
 void apply_RII(pbqp *pbqp);
 void apply_RN(pbqp *pbqp);

diff --git a/pbqp_edge.c b/pbqp_edge.c
index f12e2f0..610b53c 100644 (file)
--- a/pbqp_edge.c
+++ b/pbqp_edge.c
@@ -44,6 +44,7 @@ pbqp_edge *alloc_edge(pbqp *pbqp, int src_index, int tgt_index, pbqp_matrix *cos
        edge->src = src_node;
        ARR_APP1(pbqp_edge *, tgt_node->edges, edge);
        edge->tgt = tgt_node;
+       edge->bucket_index = UINT_MAX;
 
        return edge;
 }

diff --git a/pbqp_edge_t.h b/pbqp_edge_t.h
index 0e04321..402a362 100644 (file)
--- a/pbqp_edge_t.h
+++ b/pbqp_edge_t.h
@@ -7,6 +7,7 @@ struct pbqp_edge {
        pbqp_node   *src;                  /* Source index. */
        pbqp_node   *tgt;                  /* Target index. */
        pbqp_matrix *costs;                /* Cost matrix. */
+       unsigned     bucket_index;         /* Index of edge bucket. */
 };
 
 #endif /* KAPS_PBQP_EDGE_T_H */

diff --git a/pbqp_node.c b/pbqp_node.c
index eed9aa9..f20954f 100644 (file)
--- a/pbqp_node.c
+++ b/pbqp_node.c
@@ -4,6 +4,7 @@
 
 #include "pbqp_node.h"
 #include "pbqp_node_t.h"
+#include "pbqp_edge_t.h"
 #include "vector.h"
 
 pbqp_node *alloc_node(pbqp *pbqp, unsigned node_index, vector *costs)
@@ -20,6 +21,30 @@ pbqp_node *alloc_node(pbqp *pbqp, unsigned node_index, vector *costs)
        return node;
 }
 
+int is_connected(pbqp_node *node, pbqp_edge *edge)
+{
+       pbqp_edge **edges;
+       unsigned    edge_index;
+       unsigned    edge_len;
+
+       assert(node);
+       assert(edge);
+
+       if (edge->src != node && edge->tgt != node) return 0;
+
+       edges = node->edges;
+       edge_len = ARR_LEN(edges);
+
+       for (edge_index = 0; edge_index < edge_len; ++edge_index) {
+               pbqp_edge *edge_candidate = edges[edge_index];
+               if (edge_candidate == edge) {
+                       return 1;
+               }
+       }
+
+       return 0;
+}
+
 void disconnect_edge(pbqp_node *node, pbqp_edge *edge)
 {
        pbqp_edge **edges;

diff --git a/pbqp_node.h b/pbqp_node.h
index 047c868..6c9025b 100644 (file)
--- a/pbqp_node.h
+++ b/pbqp_node.h
@@ -7,4 +7,6 @@ pbqp_node *alloc_node(pbqp *pbqp, unsigned node_index, vector *costs);
 
 void disconnect_edge(pbqp_node *node, pbqp_edge *edge);
 
+int is_connected(pbqp_node *node, pbqp_edge *edge);
+
 #endif /* KAPS_PBQP_NODE_H */