Merge pull request #42 from elecbug/elecbug/master

Update v0.12.3

Author: elecbug

v2/graph/analyzer/analyzer_test.go

@@ -11,7 +11,8 @@ import (
 	"github.com/elecbug/netkit/v2/graph/standard"
 )
 
-// TestShortestPaths tests the ShortestPaths method of the Analyzer to ensure it correctly finds the shortest path between two nodes in a graph.
+// TestShortestPaths tests the functionality of the Analyzer's shortest path computations, including
+// cache management and performance with different parallel core counts.
 func TestShortestPaths(t *testing.T) {
 	fmt.Println("Test Shortest Paths")
 	testComputeShortestPath(t)
@@ -86,6 +87,9 @@ func testComputeShortestPath(t *testing.T) {
 	}
 }
 
+// testPerformance creates a larger random graph and tests the performance of the ShortestPaths method with different
+// parallel core counts. It measures the time taken to compute shortest paths and to retrieve cached results, ensuring
+// that the method works correctly and efficiently under various conditions.
 func testPerformance(t *testing.T) {
 	fmt.Println("- Test Performance")
 
@@ -103,45 +107,62 @@ func testPerformance(t *testing.T) {
 	a := analyzer.NewAnalyzer(g, 1)
 
 	startTime := time.Now()
-	_, err = a.ShortestPaths("0", "999")
+	paths, err := a.ShortestPaths("0", "999")
+	// NOTE: paths may be empty if 0 and 999 are not connected (P(no path) ≈ 0.009%),
+	// but we just want to test the performance of the method,
+	// so we won't fail the test in that case.
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
+	} else if len(paths) > 0 {
+		fmt.Printf("  - Found shortest paths from 0 to 999: %v\n", paths[0])
 	}
 	duration := time.Since(startTime)
 	fmt.Printf("  - Time taken to compute shortest paths: %v\n", duration)
 
 	a = analyzer.NewAnalyzer(g, 4)
 
 	startTime = time.Now()
-	_, err = a.ShortestPaths("0", "999")
+	pathsCompared, err := a.ShortestPaths("0", "999")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	duration = time.Since(startTime)
 	fmt.Printf("  - Time taken to compute shortest paths with 4 cores: %v\n", duration)
 
+	if paths[0].TotalDistance() != pathsCompared[0].TotalDistance() {
+		t.Errorf("expected total distance %v, got %v", paths[0].TotalDistance(), pathsCompared[0].TotalDistance())
+	}
+
 	a = analyzer.NewAnalyzer(g, 16)
 
 	startTime = time.Now()
-	_, err = a.ShortestPaths("0", "999")
+	pathsCompared, err = a.ShortestPaths("0", "999")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	duration = time.Since(startTime)
 	fmt.Printf("  - Time taken to compute shortest paths with 16 cores: %v\n", duration)
 
+	if paths[0].TotalDistance() != pathsCompared[0].TotalDistance() {
+		t.Errorf("expected total distance %v, got %v", paths[0].TotalDistance(), pathsCompared[0].TotalDistance())
+	}
+
 	a = analyzer.NewAnalyzer(g, 32)
 
 	startTime = time.Now()
-	_, err = a.ShortestPaths("0", "999")
+	pathsCompared, err = a.ShortestPaths("0", "999")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	duration = time.Since(startTime)
 	fmt.Printf("  - Time taken to compute shortest paths with 32 cores: %v\n", duration)
 
+	if paths[0].TotalDistance() != pathsCompared[0].TotalDistance() {
+		t.Errorf("expected total distance %v, got %v", paths[0].TotalDistance(), pathsCompared[0].TotalDistance())
+	}
+
 	startTime = time.Now()
-	_, err = a.ShortestPaths("0", "999")
+	_, err = a.ShortestPaths("0", "1")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

v2/graph/node.go

@@ -12,13 +12,15 @@ type Weight float64
 type Node struct {
 	ID    NodeID            // ID is the unique identifier for the node.
 	edges map[NodeID]Weight // Edges maps the destination NodeID to the weight of the edge.
+	tags  map[string]string // Tags can hold additional metadata about the node.
 }
 
 // NewNode creates a new node with the given ID.
 func NewNode(id NodeID) *Node {
 	return &Node{
 		ID:    id,
 		edges: make(map[NodeID]Weight),
+		tags:  make(map[string]string),
 	}
 }
 
@@ -60,6 +62,50 @@ func (n *Node) edgeWeight(to NodeID) (Weight, error) {
 	return weight, nil
 }
 
+/* Tagging */
+
+// AddTag adds a key-value pair as a tag to the node.
+// It returns an error if a tag with the same key already exists.
+func (n *Node) AddTag(key, value string) error {
+	if n.HasTag(key) {
+		return fmt.Errorf("tag with key %s already exists", key)
+	}
+
+	n.tags[key] = value
+	return nil
+}
+
+// UpdateTag updates the value of an existing tag on the node.
+// If the tag does not exist, it will be added.
+func (n *Node) UpdateTag(key, value string) {
+	n.tags[key] = value
+}
+
+// RemoveTag removes a tag from the node by its key. It returns an error if the tag does not exist.
+func (n *Node) RemoveTag(key string) error {
+	if _, exists := n.tags[key]; !exists {
+		return fmt.Errorf("tag with key %s does not exist", key)
+	}
+
+	delete(n.tags, key)
+	return nil
+}
+
+// HasTag checks if a tag with the specified key exists on the node.
+func (n *Node) HasTag(key string) bool {
+	_, exists := n.tags[key]
+	return exists
+}
+
+// Tag retrieves the value of a tag by its key. It returns an error if the tag does not exist.
+func (n *Node) Tag(key string) (string, bool) {
+	value, exists := n.tags[key]
+	if !exists {
+		return "", false
+	}
+	return value, true
+}
+
 /* Connectivity */
 
 // Neighbors returns a slice of NodeIDs representing the neighbors of this node.

v2/graph/standard/common.go

@@ -14,6 +14,8 @@ type WeightedFunc func(from, to graph.NodeID) *graph.Weight
 type GraphType string
 
 const (
+	Grid            GraphType = "grid"
+	TriangleHex     GraphType = "triangle_hex"
 	ErdosRenyi      GraphType = "erdos_renyi"
 	BarabasiAlbert  GraphType = "barabasi_albert"
 	WattsStrogatz   GraphType = "watts_strogatz"
@@ -52,6 +54,26 @@ func Unweighted() WeightedFunc {
 // StandardGraph generates a graph based on the provided configuration. It supports various graph types and parameters.
 func StandardGraph(seed int, directed bool, weightFunc WeightedFunc, config GraphConfig) (*graph.Graph, error) {
 	switch config.Type {
+	case Grid:
+		rows, ok := config.Params["rows"].(int)
+		if !ok {
+			return nil, fmt.Errorf("invalid parameter 'rows' for grid graph")
+		}
+		cols, ok := config.Params["cols"].(int)
+		if !ok {
+			return nil, fmt.Errorf("invalid parameter 'cols' for grid graph")
+		}
+		torus, ok := config.Params["torus"].(bool)
+		if !ok {
+			return nil, fmt.Errorf("invalid parameter 'torus' for grid graph")
+		}
+		return GridGraph(seed, directed, weightFunc, rows, cols, torus)
+	case TriangleHex:
+		edge, ok := config.Params["edge"].(int)
+		if !ok {
+			return nil, fmt.Errorf("invalid parameter 'edge' for triangle hex graph")
+		}
+		return TriangleHexGraph(seed, directed, weightFunc, edge)
 	case ErdosRenyi:
 		n, ok := config.Params["n"].(int)
 		if !ok {

v2/graph/standard/grid.go

@@ -0,0 +1,74 @@
+package standard
+
+import (
+	"fmt"
+
+	"github.com/elecbug/netkit/v2/graph"
+)
+
+// GridGraph generates a grid graph with the specified number of rows and columns.
+// If torus is true, the graph will wrap around at the edges, creating a toroidal structure.
+func GridGraph(seed int, directed bool, weightFunc WeightedFunc, rows, cols int, torus bool) (*graph.Graph, error) {
+	if weightFunc == nil {
+		weightFunc = Unweighted()
+	}
+	if rows < 0 || cols < 0 {
+		return nil, fmt.Errorf("rows and cols must be non-negative")
+	}
+
+	g := graph.New(directed, true)
+
+	nodeID := func(row, col int) graph.NodeID {
+		return graph.NodeID(fmt.Sprintf("%d", row*cols+col))
+	}
+
+	for i := 0; i < rows; i++ {
+		for j := 0; j < cols; j++ {
+			g.AddNode(nodeID(i, j))
+			if node, err := g.Node(nodeID(i, j)); err != nil {
+				return nil, fmt.Errorf("failed to retrieve node: %w", err)
+			} else {
+				node.AddTag("x", fmt.Sprintf("%d", i))
+				node.AddTag("y", fmt.Sprintf("%d", j))
+			}
+		}
+	}
+
+	for i := 0; i < rows; i++ {
+		for j := 0; j < cols; j++ {
+			id := nodeID(i, j)
+
+			if torus {
+				if rows > 2 {
+					ni := (i + 1) % rows
+					if err := g.AddEdge(id, nodeID(ni, j), weightFunc(id, nodeID(ni, j))); err != nil {
+						return nil, fmt.Errorf("failed to add edge: %w", err)
+					}
+				}
+			} else {
+				if i < rows-1 {
+					if err := g.AddEdge(id, nodeID(i+1, j), weightFunc(id, nodeID(i+1, j))); err != nil {
+						return nil, fmt.Errorf("failed to add edge: %w", err)
+					}
+				}
+			}
+
+			if torus {
+				if cols > 2 {
+					nj := (j + 1) % cols
+					if err := g.AddEdge(id, nodeID(i, nj), weightFunc(id, nodeID(i, nj))); err != nil {
+						return nil, fmt.Errorf("failed to add edge: %w", err)
+					}
+				}
+			} else {
+				if j < cols-1 {
+					if err := g.AddEdge(id, nodeID(i, j+1), weightFunc(id, nodeID(i, j+1))); err != nil {
+						return nil, fmt.Errorf("failed to add edge: %w", err)
+					}
+				}
+			}
+		}
+	}
+
+	return g, nil
+}

v2/graph/standard/random_geometric.go

@@ -33,6 +33,12 @@ func RandomGeometricGraph(seed int, directed bool, weightFunc WeightedFunc, n in
 		if err := g.AddNode(id); err != nil {
 			return nil, fmt.Errorf("failed to add node: %w", err)
 		}
+		if node, err := g.Node(id); err != nil {
+			return nil, fmt.Errorf("failed to retrieve node: %w", err)
+		} else {
+			node.AddTag("x", fmt.Sprintf("%f", rr.Float64()))
+			node.AddTag("y", fmt.Sprintf("%f", rr.Float64()))
+		}
 		positions[id] = point{
 			x: rr.Float64(),
 			y: rr.Float64(),