Added new algorithm test, various bug fixes and improvements

algorithms/algorithms.go

@@ -1,6 +1,5 @@
 // This package implements various algorithms to compute Generalized Hypertree Decompositions as well as
-// the more restricted set of Hypertree Deocmpositions.
-
+// the more restricted set of Hypertree Decompositions.
 package algorithms
 
 import "github.com/cem-okulmus/BalancedGo/lib"

algorithms/balsepGlobal.go

@@ -1,7 +1,6 @@
 package algorithms
 
 import (
-	"log"
 	"reflect"
 	"runtime"
 
@@ -93,7 +92,7 @@ func rerooting(H lib.Graph, balsep lib.Edges, subtrees []lib.Decomp) lib.Decomp
 	for _, s := range subtrees {
 		// fmt.Println("H ", H, "balsep ", balsep, "comp ", s.Graph)
 		s.Root = s.Root.Reroot(rerootNode)
-		log.Printf("Rerooted Decomp: %v\n", s)
+		// log.Printf("Rerooted Decomp: %v\n", s)
 		output.Children = append(output.Children, s.Root.Children...)
 	}
 	// log.Println("H: ", H, "output: ", output)

algorithms/balsepHybrid.go

@@ -111,13 +111,15 @@ func (b BalSepHybrid) findDecomp(currentDepth int, H lib.Graph) lib.Decomp {
 
 						// Base case handling
 						//stop if there are at most two special edges left
-						if comps[i].Len() <= 2 {
+						if comps[i].Len() <= 1 {
+							comps[i].Special = append(comps[i].Special, SepSpecial)
 							ch <- baseCaseSmart(b.Graph, comps[i])
 							return
 						}
 
 						//Early termination
-						if comps[i].Edges.Len() <= b.K && len(comps[i].Special) == 1 {
+						if comps[i].Edges.Len() <= b.K && len(comps[i].Special) == 0 {
+							comps[i].Special = append(comps[i].Special, SepSpecial)
 							ch <- earlyTermination(comps[i])
 							return
 						}
@@ -126,12 +128,12 @@ func (b BalSepHybrid) findDecomp(currentDepth int, H lib.Graph) lib.Decomp {
 						det.cache.Init()
 
 						result := det.findDecomp(comps[i], balsep.Vertices())
-						if !reflect.DeepEqual(result, lib.Decomp{}) && currentDepth == 0 {
+						if !reflect.DeepEqual(result, lib.Decomp{}) {
 							result.SkipRerooting = true
 						} else {
 							// comps[i].Special = append(comps[i].Special, SepSpecial)
-							// res2 := b.findDecompBalSep(1000, comps[i])
-							// if !reflect.DeepEqual(res2, Decomp{}) {
+							// res2 := b.findDecomp(1000, comps[i])
+							// if !reflect.DeepEqual(res2, lib.Decomp{}) {
 							// 	fmt.Println("Result, ", res2)
 							// 	fmt.Println("H: ", comps[i], "balsep ", balsep)
 							// 	log.Panicln("Something is rotten in the state of this program")

algorithms/detKDecomp.go

@@ -18,6 +18,8 @@ type DetKDecomp struct {
 
 // SetWidth sets the current width parameter of the algorithm
 func (d *DetKDecomp) SetWidth(K int) {
+	d.cache.Reset() // reset the cache as the new width might invalidate any old results
+
 	d.K = K
 }
 
@@ -181,9 +183,9 @@ OUTER:
 
 							d.cache.AddNegative(sepActual, comps[i])
 							// log.Printf("detK REJECTING %v: couldn't decompose %v  \n",
-							// 	Graph{Edges: sepActual}, comps[i])
-							// log.Printf("\n\nCurrent oldSep: %v\n", PrintVertices(oldSep))
-							// log.Printf("Current SubGraph: %v ( %v edges)\n", H, H.Edges.Len(), H.Edges.Hash())
+							// 	lib.Graph{Edges: sepActual}, comps[i])
+							// log.Printf("\n\nCurrent oldSep: %v\n", lib.PrintVertices(oldSep))
+							// log.Printf("Current SubGraph: %v ( %v edges) %v\n", H, H.Edges.Len(), H.Edges.Hash())
 
 							if d.SubEdge {
 								if sepSub == nil {
@@ -209,8 +211,8 @@ OUTER:
 										}
 									}
 								}
-								// log.Printf("Sub Sep chosen: %vof %v \n", Graph{Edges: sepActual},
-								// 	Graph{Edges: sepActualOrigin})
+								// log.Printf("Sub Sep chosen: %vof %v \n", lib.Graph{Edges: sepActual},
+								// 	lib.Graph{Edges: sepActualOrigin})
 								continue subEdges
 							}
 

algorithms/logKDecomp.go

@@ -27,6 +27,8 @@ type decompInt struct {
 
 // SetWidth sets the current width parameter of the algorithm
 func (l *LogKDecomp) SetWidth(K int) {
+	l.cache.Reset() // reset the cache as the new width might invalidate any old results
+
 	l.K = K
 }
 

algorithms/logkHybrid.go

@@ -90,6 +90,8 @@ func (l *LogKHybrid) ETimesKDivAvgEdgePred(H lib.Graph, K int) bool {
 
 // SetWidth sets the current width parameter of the algorithm
 func (l *LogKHybrid) SetWidth(K int) {
+	l.cache.Reset() // reset the cache as the new width might invalidate any old results
+
 	l.K = K
 }
 

balanced.go

@@ -12,7 +12,6 @@
 // In addition to this, there is also a tool subdirectory in the repository which is intended to support functionality
 // not directly related to the computation of decompositions, such as changing the formatting of hypergraphs, or fixing
 // a faulty decomposition.
-
 package main
 
 import (
@@ -412,7 +411,8 @@ func main() {
 
 	if *globalBal {
 		global := &algo.BalSepGlobal{
-			K: *width, Graph: parsedGraph,
+			K:         *width,
+			Graph:     parsedGraph,
 			BalFactor: BalFactor,
 		}
 		solver = global

lib/base.go

@@ -1,6 +1,5 @@
 // This package provides various functions, data structures and methods to aid in the design of algorithms to
-// compute structural decomposition methodds.
-
+// compute structural decomposition methods.
 package lib
 
 import (

lib/cache.go

@@ -30,6 +30,18 @@ func (c *Cache) CopyRef(other *Cache) {
 	other.once.Do(func() {}) // if cache is copied, it's assumed to already be initialised, so once is pre-fired here
 }
 
+// Reset will throw out all saved cache entries
+func (c *Cache) Reset() {
+	if c.cacheMux == nil {
+		return // don't do anything if cache wasn't initialised yet
+	}
+	c.cacheMux.Lock()
+	defer c.cacheMux.Unlock()
+
+	c.cache = make(map[uint64]*compCache)
+
+}
+
 // Init needs to be called to initialise the cache
 func (c *Cache) Init() {
 	c.once.Do(c.initFunction)
@@ -45,8 +57,8 @@ func (c *Cache) initFunction() {
 
 // Len returns the number of bindings in the cache
 func (c *Cache) Len() int {
-	c.cacheMux.Lock()
-	defer c.cacheMux.Unlock()
+	c.cacheMux.RLock()
+	defer c.cacheMux.RUnlock()
 
 	return len(c.cache)
 }

lib/edge.go

@@ -6,6 +6,7 @@ import (
 	"math"
 	"reflect"
 	"sort"
+	"strconv"
 	"sync"
 )
 
@@ -295,3 +296,24 @@ func (e *Edges) Diff(other Edges) Edges {
 
 	return NewEdges(output)
 }
+
+// FullString always prints the list of vertices of an edge, even if the edge is named
+func (e Edge) FullStringInt() string {
+	var buffer bytes.Buffer
+	mutex.RLock()
+	defer mutex.RUnlock()
+	if e.Name > 0 {
+		buffer.WriteString("E" + strconv.Itoa(e.Name))
+	}
+	buffer.WriteString(" (")
+	for i, n := range e.Vertices {
+		var s string
+		s = fmt.Sprintf("V%v", n)
+		buffer.WriteString(s)
+		if i != len(e.Vertices)-1 {
+			buffer.WriteString(", ")
+		}
+	}
+	buffer.WriteString(")")
+	return buffer.String()
+}

lib/graph.go

@@ -303,3 +303,18 @@ func (g Graph) GetBIP() int {
 
 	return output
 }
+
+//ToHyperBench format transforms the graph structure to a string in HyperBench Format. This is only relevant for generated instances with no existing string representation. Using this with a parsed graph is not the target use case, only used for internal testing
+func (g Graph) ToHyberBenchFormat() string {
+	var buffer bytes.Buffer
+
+	for i, e := range g.Edges.Slice() {
+		buffer.WriteString(e.FullStringInt())
+		if i != g.Edges.Len()-1 {
+			buffer.WriteString(",\n")
+		}
+	}
+
+	buffer.WriteString(".")
+	return buffer.String()
+}

lib/parser.go

@@ -132,7 +132,7 @@ type parseEdgePACE struct {
 }
 
 type parseGraphPACEInfo struct {
-	Vertices int `"p htd":Begin @(Number) `
+	Vertices int `"p htd" @(Number) `
 	Edges    int `@(Number) "\n"`
 }
 
@@ -149,7 +149,7 @@ func GetGraphPACE(s string) Graph {
     Comment = ("c" | "//") { "\u0000"…"\uffff"-"\n" } Newline.
     Begin = "p htd" .
     Number = ("." | digit | "_"){"." | digit | stuff } .
-    Whitespace = " " | "\t" | "\n" | "\r" .
+    Whitespace = " " | "\t" | "\r" .
     stuff = ":" | "@" | ";" | "-" | "_" .
     Punct = "!"…"/"  .
     Newline = "\n" .