TopologicalSort now supports more generic input, updated examples

Author: amwolff

README.md

@@ -1,2 +1,27 @@
 # gorder
-Golang implementation of topological sorting algorithms for fast ordering.
+
+A golang implementation of topological sorting algorithms for fast ordering.
+
+## Installation:
+
+`$ go get -u github.com/amwolff/gorder`
+
+## Usage:
+
+Check `cmd/example/example.go` for example usage.
+
+```
+$ go run cmd/example/example.go
+Solution (Kahn): [1 {3.141592653589793} 3 5 4]
+Solution (DFS-based): [1 {3.141592653589793} 3 5 4]
+```
+
+## Notes:
+
+* Maps are one of the common ways to store graphs in Go. The `TopologicalSort` function input supports `map[interface{}][]interface{}` maps.
+
+* Sub-package `dagenerator` was developed and used for generating random DAGs for performance tests (`cmd/measurements` should be rewritten as benchmarks).
+
+* Implementation of Kahn's algorithm does pre-computation in the beginning of it's work in order to calculate indegree of every vertex in the graph. This may be split into two separate algorithms/functions in the future:
+    - one that doesn't take any additional input but the graph (current implementation)
+    - and one that takes additional input of indegrees

cmd/example-2/example_2.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/amwolff/gorder"
+	"github.com/sirupsen/logrus"
+)
+
+func serialize(m map[int][]int) map[interface{}][]interface{} {
+	s := make(map[interface{}][]interface{})
+	for k, v := range m {
+		for _, val := range v {
+			s[k] = append(s[k], val)
+		}
+	}
+	return s
+}
+
+func deserialize(o []interface{}) []int {
+	d := make([]int, len(o))
+	for i := range o {
+		d[i] = o[i].(int)
+	}
+	return d
+}
+
+func main() {
+	var (
+		output []interface{}
+		err    error
+	)
+
+	digraph := map[int][]int{
+		1: []int{2, 4},
+		2: []int{3, 5},
+		3: []int{4, 5},
+	}
+
+	output, err = gorder.TopologicalSort(serialize(digraph), "kahn")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	fmt.Printf("Solution (Kahn): %d\n", deserialize(output))
+
+	output, err = gorder.TopologicalSort(serialize(digraph), "dfsbased")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	fmt.Printf("Solution (DFS-based): %d\n", deserialize(output))
+}

cmd/example/example.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/amwolff/gorder"
+	"github.com/sirupsen/logrus"
+)
+
+func main() {
+	var (
+		a   struct{ Pi float64 }
+		o   []interface{}
+		err error
+	)
+
+	a.Pi = math.Pi
+
+	digraph := map[interface{}][]interface{}{
+		1: []interface{}{a, "4"},
+		a: []interface{}{3, "5"},
+		3: []interface{}{"4", "5"},
+	}
+
+	o, err = gorder.TopologicalSort(digraph, "kahn")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	fmt.Printf("Solution (Kahn): %v\n", o)
+
+	o, err = gorder.TopologicalSort(digraph, "dfsbased")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	fmt.Printf("Solution (DFS-based): %v\n", o)
+}

cmd/measurements/measurements.go

@@ -10,26 +10,23 @@ import (
 )
 
 func main() {
-	logger := logrus.StandardLogger()
-	logger.SetLevel(logrus.DebugLevel)
-
 	start := time.Now()
 	graph := dagenerator.Generate(10, 50, 30, 50, 30)
-	logger.Infof("DAG generation time: %v", time.Since(start))
+	logrus.Infof("DAG generation time: %v", time.Since(start))
 
 	start = time.Now()
 	s, err := gorder.TopologicalSort(graph, "kahn")
-	logger.Infof("Kahn resolve time: %v", time.Since(start))
+	logrus.Infof("Kahn resolve time: %v", time.Since(start))
 	if err != nil {
-		logger.Fatal(err)
+		logrus.Fatal(err)
 	}
 	spew.Dump(s)
 
 	start = time.Now()
 	s, err = gorder.TopologicalSort(graph, "dfsbased")
-	logger.Infof("DFS-based resolve time: %v", time.Since(start))
+	logrus.Infof("DFS-based resolve time: %v", time.Since(start))
 	if err != nil {
-		logger.Fatal(err)
+		logrus.Fatal(err)
 	}
 	spew.Dump(s)
 }

dagenerator/dagenerator.go

@@ -7,10 +7,10 @@ import (
 	"time"
 )
 
-func Generate(minPerRank, maxPerRank, minRanks, maxRanks, percent int) (digraph map[int][]int) {
+func Generate(minPerRank, maxPerRank, minRanks, maxRanks, percent int) (digraph map[interface{}][]interface{}) {
 	var j, k, nodes int
 	random := rand.New(rand.NewSource(time.Now().UnixNano()))
-	digraph = make(map[int][]int)
+	digraph = make(map[interface{}][]interface{})
 
 	ranks := minRanks + int(math.Mod(random.Float64(), float64(maxRanks-minRanks+1)))
 	for i := 0; i < ranks; i++ {

gorder.go

@@ -5,7 +5,7 @@ import (
 	"regexp"
 )
 
-func TopologicalSort(digraph map[int][]int, algorithm string) (solution []int, err error) {
+func TopologicalSort(digraph map[interface{}][]interface{}, algorithm string) (solution []interface{}, err error) {
 	kahnRgxp, err := regexp.Compile(`[Kk]ahn\z`)
 	if err != nil {
 		return nil, err
@@ -29,57 +29,57 @@ func TopologicalSort(digraph map[int][]int, algorithm string) (solution []int, e
 	return solution, nil
 }
 
-func kahn(digraph map[int][]int) ([]int, error) {
-	inDegree := make(map[int]int)
+func kahn(digraph map[interface{}][]interface{}) ([]interface{}, error) {
+	indegrees := make(map[interface{}]int)
 	for u := range digraph {
 		if digraph[u] != nil {
 			for _, v := range digraph[u] {
-				inDegree[v]++
+				indegrees[v]++
 			}
 		}
 	}
 
-	var queue []int
+	var queue []interface{}
 	for u := range digraph {
-		if _, ok := inDegree[u]; !ok {
+		if _, ok := indegrees[u]; !ok {
 			queue = append(queue, u)
 		}
 	}
 
-	var order []int
+	var order []interface{}
 	for len(queue) > 0 {
 		u := queue[len(queue)-1]
 		queue = queue[:(len(queue) - 1)]
 		order = append(order, u)
 		for _, v := range digraph[u] {
-			inDegree[v]--
-			if inDegree[v] == 0 {
+			indegrees[v]--
+			if indegrees[v] == 0 {
 				queue = append(queue, v)
 			}
 		}
 	}
 
-	for _, in := range inDegree {
-		if in > 0 {
-			return order, errors.New("Kahn: not a DAG")
+	for _, indegree := range indegrees {
+		if indegree > 0 {
+			return order, errors.New("not a DAG")
 		}
 	}
 	return order, nil
 }
 
-func dfsBased(digraph map[int][]int) ([]int, error) {
+func dfsBased(digraph map[interface{}][]interface{}) ([]interface{}, error) {
 	var (
 		acyclic       = true
-		order         []int
-		permanentMark = make(map[int]bool)
-		temporaryMark = make(map[int]bool)
-		visit         func(int)
+		order         []interface{}
+		permanentMark = make(map[interface{}]bool)
+		temporaryMark = make(map[interface{}]bool)
+		visit         func(interface{})
 	)
 
-	visit = func(u int) {
+	visit = func(u interface{}) {
 		if temporaryMark[u] {
 			acyclic = false
-		} else if !permanentMark[u] {
+		} else if !(temporaryMark[u] || permanentMark[u]) {
 			temporaryMark[u] = true
 			for _, v := range digraph[u] {
 				visit(v)
@@ -89,15 +89,15 @@ func dfsBased(digraph map[int][]int) ([]int, error) {
 			}
 			delete(temporaryMark, u)
 			permanentMark[u] = true
-			order = append([]int{u}, order...)
+			order = append([]interface{}{u}, order...)
 		}
 	}
 
 	for u := range digraph {
 		if !permanentMark[u] {
 			visit(u)
 			if !acyclic {
-				return order, errors.New("DFS-based: not a DAG")
+				return order, errors.New("not a DAG")
 			}
 		}
 	}

gorder_test.go

@@ -3,11 +3,12 @@ package gorder
 import "testing"
 
 func TestTopologicalSort(t *testing.T) {
-	digraph := map[int][]int{
-		1: []int{2, 4},
-		2: []int{3, 5},
-		3: []int{4, 5},
+	digraph := map[interface{}][]interface{}{
+		1: []interface{}{2, 4},
+		2: []interface{}{3, 5},
+		3: []interface{}{4, 5},
 	}
+
 	want := []int{1, 2, 3, 5, 4}
 
 	_, err := TopologicalSort(digraph, "ultrasuperfast")
@@ -35,17 +36,16 @@ func TestTopologicalSort(t *testing.T) {
 		}
 	}
 
-	graphWithCycles := map[int][]int{
-		1: []int{2, 4},
-		2: []int{3, 5},
-		3: []int{4, 5},
-		4: []int{2},
+	graphWithCycles := map[interface{}][]interface{}{
+		1: []interface{}{2, 4},
+		2: []interface{}{3, 5},
+		3: []interface{}{4, 5},
+		4: []interface{}{2},
 	}
 	_, err = TopologicalSort(graphWithCycles, "kahn")
 	if err == nil {
 		t.Fatal("Kahn: should have returned an error")
 	}
-
 	_, err = TopologicalSort(graphWithCycles, "dfsbased")
 	if err == nil {
 		t.Fatal("DFS-based: should have returned an error")