feat(graph-modeling): improve graph types and add tests for complete graph

Author: rozanecm

.github/workflows/go.yml

@@ -17,7 +17,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v4
       with:
-        go-version: '1.20'
+        go-version: '1.21'
 
     - name: Build
       run: go build -v ./...

io/io.go

@@ -50,22 +50,22 @@ func FromAdjacencyList(reader io.Reader) {
 			return
 		}
 		slog.Info(fmt.Sprintf("read: %+v", read))
-		g.AddEdgesFromIntEdgeList(lineCount, lineToList(read))
+		g.AddEdgesFromIntEdgeList(model.Node(lineCount), lineToList(read))
 		lineCount++
 	}
 
 	// todo remove this log
 	slog.Info(fmt.Sprintf("graph: %+v", g))
 }
 
-func lineToList(values []string) (integers []int) {
-	integers = make([]int, len(values))
+func lineToList(values []string) (integers []model.Node) {
+	integers = make([]model.Node, len(values))
 	for index, value := range values {
 		valueInt, err := strconv.Atoi(value)
 		if err != nil {
 			panic(err)
 		}
-		integers[index] = valueInt
+		integers[index] = model.Node(valueInt)
 	}
 	return
 }

model/generator_classic.go

@@ -1,12 +1,12 @@
 package model
 
-func CompleteGraph(numberOfNodes int) (g UndirectedGraph) {
-	g = UndirectedGraph{}
-	for i := 0; i <= numberOfNodes; i++ {
-		for j := i + 1; j <= numberOfNodes; i++ {
+func CompleteGraph(numberOfNodes int) *UndirectedGraph {
+	g := &UndirectedGraph{}
+	for i := 0; i < numberOfNodes; i++ {
+		for j := i + 1; j < numberOfNodes; j++ {
 			g.AddEdge(Edge{
-				Node1: Node{NodeId: i},
-				Node2: Node{NodeId: j},
+				Node1: Node(i),
+				Node2: Node(j),
 			})
 		}
 	}
@@ -22,8 +22,8 @@ func LadderGraph(nodesInSinglePath int) (g UndirectedGraph) {
 	}
 	for i := 0; i <= nodesInSinglePath; i++ {
 		g.AddEdge(Edge{
-			Node1: Node{NodeId: i},
-			Node2: Node{NodeId: i + nodesInSinglePath},
+			Node1: Node(i),
+			Node2: Node(i + nodesInSinglePath),
 		})
 	}
 	return g
@@ -33,12 +33,11 @@ func LadderGraph(nodesInSinglePath int) (g UndirectedGraph) {
 func CircularLadderGraph(nodesInSinglePath int) (g UndirectedGraph) {
 	g = LadderGraph(nodesInSinglePath)
 	g.AddEdge(Edge{
-		Node1: Node{},
-		Node2: Node{NodeId: nodesInSinglePath - 1},
+		Node2: Node(nodesInSinglePath - 1),
 	})
 	g.AddEdge(Edge{
-		Node1: Node{NodeId: nodesInSinglePath},
-		Node2: Node{NodeId: 2*nodesInSinglePath - 1},
+		Node1: Node(nodesInSinglePath),
+		Node2: Node(2*nodesInSinglePath - 1),
 	})
 	return g
 }

model/generator_classic_test.go

@@ -0,0 +1,59 @@
+package model
+
+import (
+	"testing"
+)
+
+func TestCompleteGraph(t *testing.T) {
+	tests := []struct {
+		name           string
+		numberOfNodes  int
+		expectedEdges  int
+		expectedDegree int
+	}{
+		{
+			name:           "CompleteGraph with 0 nodes",
+			numberOfNodes:  0,
+			expectedEdges:  0,
+			expectedDegree: 0,
+		},
+		{
+			name:           "CompleteGraph with 2 nodes",
+			numberOfNodes:  2,
+			expectedEdges:  1, // 2C1 (combination)
+			expectedDegree: 1,
+		},
+		{
+			name:           "CompleteGraph with 5 nodes",
+			numberOfNodes:  5,
+			expectedEdges:  10, // 5C2 (combination)
+			expectedDegree: 4,
+		},
+		{
+			name:           "CompleteGraph with 10 nodes",
+			numberOfNodes:  10,
+			expectedEdges:  45, // 10C2 (combination)
+			expectedDegree: 9,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := CompleteGraph(tt.numberOfNodes)
+
+			// Check the number of edges
+			actualEdges := g.NumberOfEdges()
+			if actualEdges != tt.expectedEdges {
+				t.Errorf("Expected %d edges, but got %d", tt.expectedEdges, actualEdges)
+			}
+
+			// Check the degree of each node
+			for i := 0; i < tt.numberOfNodes; i++ {
+				actualDegree := g.NodeDegree(Node(i))
+				if actualDegree != tt.expectedDegree {
+					t.Errorf("Expected degree of node %d to be %d, but got %d", i, tt.expectedDegree, actualDegree)
+				}
+			}
+		})
+	}
+}

model/generator_random.go

@@ -30,8 +30,8 @@ import (
 // References: [1] Vladimir Batagelj and Ulrik Brandes, "Efficient generation of large random networks", Phys. Rev. E, 71, 036113, 2005.
 func FastGNPRandomGraph(numberOfNodes int, probabilityForEdgeCreation float64) (g UndirectedGraph) {
 	g = UndirectedGraph{}
-	g.Edges = make(map[int][]int)
-	g.Nodes = make(map[int]bool)
+	g.Edges = make(map[Node][]Node)
+	g.Nodes = make(map[Node]bool, numberOfNodes)
 	lp := math.Log(1.0 - probabilityForEdgeCreation)
 	// Nodes in graph are from 0,n-1 (start with v as the second node index).
 	v := 1
@@ -43,7 +43,7 @@ func FastGNPRandomGraph(numberOfNodes int, probabilityForEdgeCreation float64) (
 			w = w - v
 			v = v + 1
 			if v < numberOfNodes {
-				g.AddEdge(Edge{Node{v}, Node{w}})
+				g.AddEdge(Edge{Node(v), Node(w)})
 			}
 		}
 	}
@@ -57,12 +57,12 @@ func FastGNPRandomGraph(numberOfNodes int, probabilityForEdgeCreation float64) (
 // in section 3.4.2 of [1]
 // References: [1] Donald E. Knuth, The Art of Computer Programming,
 // Volume 2/Seminumerical algorithms, Third Edition, Addison-Wesley, 1997.
-func DenseGNMRandomGraph(numberOfNodes int, numberOfEdges int) (g UndirectedGraph) {
+func DenseGNMRandomGraph(numberOfNodes int, numberOfEdges int) (g *UndirectedGraph) {
 	edgesMax := numberOfNodes * (numberOfNodes - 1) // 2
 	if numberOfEdges >= edgesMax {
 		return CompleteGraph(numberOfNodes)
 	} else {
-		g = UndirectedGraph{}
+		g = &UndirectedGraph{}
 	}
 	if numberOfNodes == 1 || numberOfEdges >= edgesMax {
 		return g
@@ -71,7 +71,7 @@ func DenseGNMRandomGraph(numberOfNodes int, numberOfEdges int) (g UndirectedGrap
 	u, v, t, k := 0, 0, 0, 0
 	for {
 		if (t + rand.Int()*(edgesMax-t)) < (numberOfEdges - k) {
-			g.AddEdge(Edge{Node{u}, Node{v}})
+			g.AddEdge(Edge{Node(u), Node(v)})
 			k = k + 1
 			if k == numberOfEdges {
 				return g

model/graph.go

@@ -1,66 +1,86 @@
 package model
 
-import "fmt"
+import (
+	"fmt"
+)
 
 type Graph interface {
 	AddEdge(edge Edge)
 	AddNode(node Node)
 	GetEdgeTuples() []Edge
-	Sample(sampler *SamplingStrategy, samplingRate float32) Graph
+	Sample(sampler SamplingStrategy, samplingRate float32) UndirectedGraph
+	NodeDegree(node Node) int
+	NumberOfEdges() int
 }
 
-type UndirectedGraph struct {
-	Nodes map[int]bool
-	Edges map[int][]int
-}
-
-func (g UndirectedGraph) String() string {
-	return fmt.Sprintf("graph has %d nodes and %d edges", len(g.Nodes), len(g.Edges))
-}
+type Node int
 
 type Edge struct {
 	Node1 Node
 	Node2 Node
 }
 
-type Node struct {
-	NodeId int
+type UndirectedGraph struct {
+	Nodes map[Node]bool
+	Edges map[Node][]Node
+}
+
+func (g UndirectedGraph) String() string {
+	return fmt.Sprintf("graph has %d nodes and %d edges. Nodes: %v; Edges: %v", len(g.Nodes), len(g.Edges), g.Nodes, g.Edges)
 }
 
 func (g *UndirectedGraph) AddEdge(edge Edge) {
+	if g.Edges == nil {
+		g.Edges = make(map[Node][]Node)
+	}
 	g.AddNode(edge.Node1)
 	g.AddNode(edge.Node2)
-	g.Edges[edge.Node1.NodeId] = append(g.Edges[edge.Node1.NodeId], edge.Node2.NodeId)
+	g.Edges[edge.Node1] = append(g.Edges[edge.Node1], edge.Node2)
+	g.Edges[edge.Node2] = append(g.Edges[edge.Node2], edge.Node1)
 }
 
 func (g *UndirectedGraph) AddNode(node Node) {
-	g.Nodes[node.NodeId] = true
+	if g.Nodes == nil {
+		g.Nodes = make(map[Node]bool)
+	}
+	g.Nodes[node] = true
 }
 
 func (g *UndirectedGraph) AddEdgesFromIntTupleList(edges [][2]int) {
 	for _, nodes := range edges {
-		g.AddEdge(Edge{Node{nodes[0]}, Node{nodes[1]}})
+		g.AddEdge(Edge{Node(nodes[0]), Node(nodes[1])})
 	}
 }
 
-func (g *UndirectedGraph) AddEdgesFromIntEdgeList(sourceNode int, edges []int) {
+func (g *UndirectedGraph) AddEdgesFromIntEdgeList(sourceNode Node, edges []Node) {
 	for _, node := range edges {
-		g.AddEdge(Edge{Node{sourceNode}, Node{node}})
+		g.AddEdge(Edge{sourceNode, node})
 	}
 }
 
-func (g *UndirectedGraph) AddNodes(nodes map[int]bool) {
-	for node := range nodes {
-		g.AddNode(Node{node})
+func (g *UndirectedGraph) AddNodes(nodes []Node) {
+	for _, node := range nodes {
+		g.AddNode(node)
 	}
 }
 
+// NodeDegree returns the degree (number of incident edges) of the specified node in the graph.
+func (g *UndirectedGraph) NodeDegree(node Node) int {
+	// Check if the node exists in the graph
+	if _, exists := g.Nodes[node]; !exists {
+		return 0 // Node not found, degree is 0
+	}
+
+	// Retrieve the neighbors of the node and return the degree
+	return len(g.Edges[node])
+}
+
 // todo suggest rename to GetEdges
 func (g *UndirectedGraph) GetEdgeTuples() []Edge {
 	var edges []Edge
 	for node1, array := range g.Edges {
-		for node2 := range array {
-			edges = append(edges, Edge{Node{node1}, Node{node2}})
+		for _, node2 := range array {
+			edges = append(edges, Edge{node1, node2})
 		}
 	}
 	return edges
@@ -69,3 +89,16 @@ func (g *UndirectedGraph) GetEdgeTuples() []Edge {
 func (g *UndirectedGraph) Sample(sampler SamplingStrategy, samplingRate float32) UndirectedGraph {
 	return sampler.Sample(g, samplingRate)
 }
+
+// NumberOfEdges returns the total number of edges in the undirected graph.
+func (g *UndirectedGraph) NumberOfEdges() int {
+	totalEdges := 0
+
+	// Iterate over each node's neighbors and count the unique edges
+	for _, neighbors := range g.Edges {
+		totalEdges += len(neighbors)
+	}
+
+	// Divide by 2 to account for the fact that each edge is counted twice (undirected graph)
+	return totalEdges / 2
+}

model/random_sampling_test.go

@@ -16,7 +16,7 @@ func BenchmarkFastGNPRandomGraph(b *testing.B) {
 	// Run the benchmark
 	for i := 0; i < b.N; i++ {
 		// Reset the random seed for each iteration to ensure consistent results
-		rand.Seed(int64(i))
+		rand.NewSource(int64(i))
 
 		// Run the FastGNPRandomGraph function
 		g := FastGNPRandomGraph(numberOfNodes, probabilityForEdgeCreation)

model/sampling.go

@@ -32,13 +32,13 @@ func (strategy *RandomNodeSampling) Sample(g *UndirectedGraph, samplingRate floa
 	ng = UndirectedGraph{}
 	sampleSize := int(float32(len(g.Nodes)) * samplingRate)
 	for _, node := range rand.Perm(sampleSize) {
-		ng.AddNode(Node{NodeId: node})
+		ng.AddNode(Node(node))
 	}
 	for node1 := range ng.Nodes {
-		for node2 := range g.Edges[node1] {
+		for _, node2 := range g.Edges[node1] {
 			ng.AddEdge(Edge{
-				Node1: Node{node1},
-				Node2: Node{node2},
+				Node1: node1,
+				Node2: node2,
 			})
 		}
 	}
@@ -62,7 +62,7 @@ func (strategy *RandomDegreeNodeSampling) Sample(g *UndirectedGraph, samplingRat
 		}
 		pick := choice.Pick()
 		// todo make sampling without replacement
-		ng.AddNode(Node{pick.(int)})
+		ng.AddNode(Node(pick.(int)))
 	}
 	return ng, nil
 }

model/utils.go

@@ -3,7 +3,7 @@ package model
 func Pairwise(nodeIds []int) (e []Edge) {
 	e = []Edge{}
 	for i := 0; i < len(nodeIds)-1; i++ {
-		e = append(e, Edge{Node{nodeIds[i]}, Node{nodeIds[i+1]}})
+		e = append(e, Edge{Node(nodeIds[i]), Node(nodeIds[i+1])})
 	}
 	return e
 }