graph/simple: separate weighted and unweighted edge implementations

graph/community/bisect_test.go

@@ -66,7 +66,7 @@ func init() {
 			friends.AddNode(simple.Node(u))
 		}
 		for v := range e {
-			friends.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+			friends.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 		}
 	}
 	enemies = simple.NewWeightedUndirectedGraph(0, 0)
@@ -76,7 +76,7 @@ func init() {
 			enemies.AddNode(simple.Node(u))
 		}
 		for v := range e {
-			enemies.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: -1})
+			enemies.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: -1})
 		}
 	}
 }
@@ -148,7 +148,7 @@ func TestProfileWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -207,7 +207,7 @@ func TestProfileWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 

graph/community/louvain_directed_multiplex_test.go

@@ -668,7 +668,7 @@ func TestNonContiguousDirectedMultiplex(t *testing.T) {
 
 func TestNonContiguousWeightedDirectedMultiplex(t *testing.T) {
 	g := simple.NewWeightedDirectedGraph(0, 0)
-	for _, e := range []simple.Edge{
+	for _, e := range []simple.WeightedEdge{
 		{F: simple.Node(0), T: simple.Node(1), W: 1},
 		{F: simple.Node(4), T: simple.Node(5), W: 1},
 	} {
@@ -708,7 +708,7 @@ func directedMultiplexFrom(raw []layer) (DirectedLayers, []float64, error) {
 				if l.edgeWeight != 0 {
 					w = l.edgeWeight
 				}
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: w})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: w})
 			}
 		}
 		layers = append(layers, g)

graph/community/louvain_directed_test.go

@@ -225,7 +225,7 @@ func TestCommunityQWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -278,7 +278,7 @@ func TestCommunityDeltaQWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -403,7 +403,7 @@ func TestReduceQConsistencyWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -521,7 +521,7 @@ func TestMoveLocalWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -583,7 +583,7 @@ func TestModularizeWeightedDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -693,7 +693,7 @@ func TestNonContiguousDirected(t *testing.T) {
 
 func TestNonContiguousWeightedDirected(t *testing.T) {
 	g := simple.NewWeightedDirectedGraph(0, 0)
-	for _, e := range []simple.Edge{
+	for _, e := range []simple.WeightedEdge{
 		{F: simple.Node(0), T: simple.Node(1), W: 1},
 		{F: simple.Node(4), T: simple.Node(5), W: 1},
 	} {

graph/community/louvain_undirected_multiplex_test.go

@@ -637,7 +637,7 @@ func TestNonContiguousUndirectedMultiplex(t *testing.T) {
 
 func TestNonContiguousWeightedUndirectedMultiplex(t *testing.T) {
 	g := simple.NewWeightedUndirectedGraph(0, 0)
-	for _, e := range []simple.Edge{
+	for _, e := range []simple.WeightedEdge{
 		{F: simple.Node(0), T: simple.Node(1), W: 1},
 		{F: simple.Node(4), T: simple.Node(5), W: 1},
 	} {
@@ -677,7 +677,7 @@ func undirectedMultiplexFrom(raw []layer) (UndirectedLayers, []float64, error) {
 				if l.edgeWeight != 0 {
 					w = l.edgeWeight
 				}
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: w})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: w})
 			}
 		}
 		layers = append(layers, g)

graph/community/louvain_undirected_test.go

@@ -284,7 +284,7 @@ func TestCommunityQWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -337,7 +337,7 @@ func TestCommunityDeltaQWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -462,7 +462,7 @@ func TestReduceQConsistencyWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -580,7 +580,7 @@ func TestMoveLocalWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -642,7 +642,7 @@ func TestModularizeWeightedUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -752,7 +752,7 @@ func TestNonContiguousUndirected(t *testing.T) {
 
 func TestNonContiguousWeightedUndirected(t *testing.T) {
 	g := simple.NewWeightedUndirectedGraph(0, 0)
-	for _, e := range []simple.Edge{
+	for _, e := range []simple.WeightedEdge{
 		{F: simple.Node(0), T: simple.Node(1), W: 1},
 		{F: simple.Node(4), T: simple.Node(5), W: 1},
 	} {

graph/graphs/gen/batagelj_brandes.go

@@ -50,7 +50,7 @@ func Gnp(dst GraphBuilder, n int, p float64, src *rand.Rand) error {
 			v++
 		}
 		if v < n {
-			dst.SetEdge(simple.Edge{F: simple.Node(w), T: simple.Node(v), W: 1})
+			dst.SetEdge(simple.Edge{F: simple.Node(w), T: simple.Node(v)})
 		}
 	}
 
@@ -65,7 +65,7 @@ func Gnp(dst GraphBuilder, n int, p float64, src *rand.Rand) error {
 			v++
 		}
 		if v < n {
-			dst.SetEdge(simple.Edge{F: simple.Node(v), T: simple.Node(w), W: 1})
+			dst.SetEdge(simple.Edge{F: simple.Node(v), T: simple.Node(w)})
 		}
 	}
 
@@ -120,7 +120,7 @@ func Gnm(dst GraphBuilder, n, m int, src *rand.Rand) error {
 	for i := 0; i < m; i++ {
 		for {
 			v, w := edgeNodesFor(rnd(nChoose2))
-			e := simple.Edge{F: w, T: v, W: 1}
+			e := simple.Edge{F: w, T: v}
 			if !hasEdge(e.F, e.T) {
 				dst.SetEdge(e)
 				break
@@ -135,7 +135,7 @@ func Gnm(dst GraphBuilder, n, m int, src *rand.Rand) error {
 	for i := 0; i < m; i++ {
 		for {
 			v, w := edgeNodesFor(rnd(nChoose2))
-			e := simple.Edge{F: v, T: w, W: 1}
+			e := simple.Edge{F: v, T: w}
 			if !hasEdge(e.F, e.T) {
 				dst.SetEdge(e)
 				break
@@ -198,14 +198,14 @@ func SmallWorldsBB(dst GraphBuilder, n, d int, p float64, src *rand.Rand) error
 		for i := 1; i <= d; i++ {
 			if k > 0 {
 				j := v*(v-1)/2 + (v+i)%n
-				ej := simple.Edge{W: 1}
+				var ej simple.Edge
 				ej.T, ej.F = edgeNodesFor(j)
 				if !hasEdge(ej.From(), ej.To()) {
 					dst.SetEdge(ej)
 				}
 				k--
 				m++
-				em := simple.Edge{W: 1}
+				var em simple.Edge
 				em.T, em.F = edgeNodesFor(m)
 				if !hasEdge(em.From(), em.To()) {
 					replace[j] = m
@@ -219,7 +219,7 @@ func SmallWorldsBB(dst GraphBuilder, n, d int, p float64, src *rand.Rand) error
 	}
 	for i := m + 1; i <= n*d && i < nChoose2; i++ {
 		r := rndN(nChoose2-i) + i
-		er := simple.Edge{W: 1}
+		var er simple.Edge
 		er.T, er.F = edgeNodesFor(r)
 		if !hasEdge(er.From(), er.To()) {
 			dst.SetEdge(er)
@@ -229,7 +229,7 @@ func SmallWorldsBB(dst GraphBuilder, n, d int, p float64, src *rand.Rand) error
 				dst.SetEdge(er)
 			}
 		}
-		ei := simple.Edge{W: 1}
+		var ei simple.Edge
 		ei.T, ei.F = edgeNodesFor(i)
 		if !hasEdge(ei.From(), ei.To()) {
 			replace[r] = i
@@ -249,7 +249,7 @@ func SmallWorldsBB(dst GraphBuilder, n, d int, p float64, src *rand.Rand) error
 		for i := 1; i <= d; i++ {
 			if k > 0 {
 				j := v*(v-1)/2 + (v+i)%n
-				ej := simple.Edge{W: 1}
+				var ej simple.Edge
 				ej.F, ej.T = edgeNodesFor(j)
 				if !hasEdge(ej.From(), ej.To()) {
 					dst.SetEdge(ej)
@@ -268,7 +268,7 @@ func SmallWorldsBB(dst GraphBuilder, n, d int, p float64, src *rand.Rand) error
 	}
 	for i := m + 1; i <= n*d && i < nChoose2; i++ {
 		r := rndN(nChoose2-i) + i
-		er := simple.Edge{W: 1}
+		var er simple.Edge
 		er.F, er.T = edgeNodesFor(r)
 		if !hasEdge(er.From(), er.To()) {
 			dst.SetEdge(er)

graph/graphs/gen/holme_kim.go

@@ -72,7 +72,7 @@ func TunableClusteringScaleFree(dst graph.UndirectedBuilder, n, m int, p float64
 					if wid == int64(v) || dst.HasEdgeBetween(w, simple.Node(v)) {
 						continue
 					}
-					dst.SetEdge(simple.Edge{F: w, T: simple.Node(v), W: 1})
+					dst.SetEdge(simple.Edge{F: w, T: simple.Node(v)})
 					wt[wid]++
 					wt[v]++
 					continue pa
@@ -89,7 +89,7 @@ func TunableClusteringScaleFree(dst graph.UndirectedBuilder, n, m int, p float64
 				if u == v || dst.HasEdgeBetween(simple.Node(u), simple.Node(v)) {
 					continue
 				}
-				dst.SetEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				dst.SetEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v)})
 				wt[u]++
 				wt[v]++
 				break
@@ -149,7 +149,7 @@ func PreferentialAttachment(dst graph.UndirectedBuilder, n, m int, src *rand.Ran
 			if !ok {
 				return errors.New("gen: depleted distribution")
 			}
-			dst.SetEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+			dst.SetEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v)})
 			wt[u]++
 			wt[v]++
 		}

graph/graphs/gen/small_world.go

@@ -62,7 +62,7 @@ func NavigableSmallWorld(dst GraphBuilder, dims []int, p, q int, r float64, src
 				return
 			}
 			vid := idFromDelta(u, delta, dims, -p)
-			e := simple.Edge{F: simple.Node(uid), T: simple.Node(vid), W: 1}
+			e := simple.Edge{F: simple.Node(uid), T: simple.Node(vid)}
 			if uid > vid {
 				e.F, e.T = e.T, e.F
 			}
@@ -105,7 +105,7 @@ func NavigableSmallWorld(dst GraphBuilder, dims []int, p, q int, r float64, src
 			if !ok {
 				panic("depleted distribution")
 			}
-			e := simple.Edge{F: simple.Node(uid), T: simple.Node(vid), W: 1}
+			e := simple.Edge{F: simple.Node(uid), T: simple.Node(vid)}
 			if !isDirected && uid > vid {
 				e.F, e.T = e.T, e.F
 			}

graph/network/betweenness_test.go

@@ -244,7 +244,7 @@ func TestBetweennessWeighted(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 
@@ -280,7 +280,7 @@ func TestEdgeBetweennessWeighted(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 

graph/network/distance_test.go

@@ -150,7 +150,7 @@ func TestDistanceCentralityUndirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 		p, ok := path.FloydWarshall(g)
@@ -340,7 +340,7 @@ func TestDistanceCentralityDirected(t *testing.T) {
 				g.AddNode(simple.Node(u))
 			}
 			for v := range e {
-				g.SetWeightedEdge(simple.Edge{F: simple.Node(u), T: simple.Node(v), W: 1})
+				g.SetWeightedEdge(simple.WeightedEdge{F: simple.Node(u), T: simple.Node(v), W: 1})
 			}
 		}
 		p, ok := path.FloydWarshall(g)

graph/path/dynamic/dstarlite.go

@@ -104,7 +104,7 @@ func NewDStarLite(s, t graph.Node, g graph.Graph, h path.Heuristic, m WorldModel
 			if w < 0 {
 				panic("D* Lite: negative edge weight")
 			}
-			d.model.SetWeightedEdge(simple.Edge{F: u, T: d.model.Node(v.ID()), W: w})
+			d.model.SetWeightedEdge(simple.WeightedEdge{F: u, T: d.model.Node(v.ID()), W: w})
 		}
 	}
 
@@ -302,7 +302,7 @@ func (d *DStarLite) UpdateWorld(changes []graph.Edge) {
 		cOld, _ := d.model.Weight(from, to)
 		u := d.worldNodeFor(from)
 		v := d.worldNodeFor(to)
-		d.model.SetWeightedEdge(simple.Edge{F: u, T: v, W: c})
+		d.model.SetWeightedEdge(simple.WeightedEdge{F: u, T: v, W: c})
 		if cOld > c {
 			if u.ID() != d.t.ID() {
 				u.rhs = math.Min(u.rhs, c+v.g)

graph/path/dynamic/dstarlite_test.go

@@ -596,7 +596,7 @@ func TestDStarLiteDynamic(t *testing.T) {
 			}
 
 			dp.dump(true)
-			dp.printEdges("Initial world knowledge: %s\n\n", simpleEdgesOf(l, world.Edges()))
+			dp.printEdges("Initial world knowledge: %s\n\n", simpleWeightedEdgesOf(l, world.Edges()))
 			for d.Step() {
 				changes, _ := l.MoveTo(d.Here())
 				got = append(got, l.Location)
@@ -609,7 +609,7 @@ func TestDStarLiteDynamic(t *testing.T) {
 							i, memory(remember), gotPath, wantedPath)
 					}
 				}
-				dp.printEdges("Edges changing after last step:\n%s\n\n", simpleEdgesOf(l, changes))
+				dp.printEdges("Edges changing after last step:\n%s\n\n", simpleWeightedEdgesOf(l, changes))
 			}
 
 			if weight := weightOf(got, l.Grid); !samePath(got, test.want) || weight != test.weight {
@@ -667,9 +667,9 @@ func weightOf(path []graph.Node, g graph.Weighted) float64 {
 	return w
 }
 
-// simpleEdgesOf returns the weighted edges in g corresponding to the given edges.
+// simpleWeightedEdgesOf returns the weighted edges in g corresponding to the given edges.
-func simpleEdgesOf(g graph.Weighted, edges []graph.Edge) []simple.Edge {
+func simpleWeightedEdgesOf(g graph.Weighted, edges []graph.Edge) []simple.WeightedEdge {
-	w := make([]simple.Edge, len(edges))
+	w := make([]simple.WeightedEdge, len(edges))
 	for i, e := range edges {
 		w[i].F = e.From()
 		w[i].T = e.To()

graph/path/dynamic/dumper_test.go

@@ -126,7 +126,7 @@ func (d *dumper) dump(withpath bool) {
 // printEdges pretty prints the given edges to the dumper's io.Writer using the provided
 // format string. The edges are first formated to a string, so the format string must use
 // the %s verb to indicate where the edges are to be printed.
-func (d *dumper) printEdges(format string, edges []simple.Edge) {
+func (d *dumper) printEdges(format string, edges []simple.WeightedEdge) {
 	if d == nil {
 		return
 	}
@@ -144,7 +144,7 @@ func (d *dumper) printEdges(format string, edges []simple.Edge) {
 	fmt.Fprintf(d.w, format, buf.Bytes())
 }
 
-type lexically []simple.Edge
+type lexically []simple.WeightedEdge
 
 func (l lexically) Len() int { return len(l) }
 func (l lexically) Less(i, j int) bool {

graph/path/internal/grid.go

@@ -218,11 +218,11 @@ func (g *Grid) EdgeBetween(u, v graph.Node) graph.Edge {
 func (g *Grid) WeightedEdgeBetween(u, v graph.Node) graph.WeightedEdge {
 	if g.HasEdgeBetween(u, v) {
 		if !g.AllowDiagonal || g.UnitEdgeWeight {
-			return simple.Edge{F: u, T: v, W: 1}
+			return simple.WeightedEdge{F: u, T: v, W: 1}
 		}
 		ux, uy := g.XY(u)
 		vx, vy := g.XY(v)
-		return simple.Edge{F: u, T: v, W: math.Hypot(ux-vx, uy-vy)}
+		return simple.WeightedEdge{F: u, T: v, W: math.Hypot(ux-vx, uy-vy)}
 	}
 	return nil
 }

graph/path/internal/limited.go

@@ -234,11 +234,11 @@ func (l *LimitedVisionGrid) EdgeBetween(u, v graph.Node) graph.Edge {
 func (l *LimitedVisionGrid) WeightedEdgeBetween(u, v graph.Node) graph.WeightedEdge {
 	if l.HasEdgeBetween(u, v) {
 		if !l.Grid.AllowDiagonal || l.Grid.UnitEdgeWeight {
-			return simple.Edge{F: u, T: v, W: 1}
+			return simple.WeightedEdge{F: u, T: v, W: 1}
 		}
 		ux, uy := l.XY(u)
 		vx, vy := l.XY(v)
-		return simple.Edge{F: u, T: v, W: math.Hypot(ux-vx, uy-vy)}
+		return simple.WeightedEdge{F: u, T: v, W: math.Hypot(ux-vx, uy-vy)}
 	}
 	return nil
 }

graph/path/internal/limited_test.go

@@ -16,7 +16,7 @@ import (
 type changes struct {
 	n graph.Node
 
-	new, old []simple.Edge
+	new, old []simple.WeightedEdge
 }
 
 var limitedVisionTests = []struct {
@@ -44,7 +44,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -56,7 +56,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
@@ -68,7 +68,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(6), W: 1},
 					{F: simple.Node(5), T: simple.Node(6), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(2), W: 1},
@@ -82,7 +82,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(10), W: 1},
 					{F: simple.Node(9), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(6), W: 1},
@@ -96,7 +96,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(10), T: simple.Node(14), W: 1},
 					{F: simple.Node(13), T: simple.Node(14), W: math.Inf(1)},
 					{F: simple.Node(14), T: simple.Node(10), W: 1},
@@ -123,7 +123,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
@@ -143,7 +143,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
@@ -163,7 +163,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
@@ -193,7 +193,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(6), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(5), W: math.Inf(1)},
@@ -223,7 +223,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(9), W: math.Inf(1)},
@@ -258,7 +258,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -270,14 +270,14 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(6), W: 1},
 					{F: simple.Node(3), T: simple.Node(2), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(2), W: 1},
 					{F: simple.Node(6), T: simple.Node(5), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
@@ -286,14 +286,14 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(7), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(10), W: 1},
 					{F: simple.Node(7), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(7), T: simple.Node(6), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(6), W: 1},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(6), W: 1},
@@ -305,7 +305,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(9), W: math.Inf(1)},
@@ -315,7 +315,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(11), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(14), T: simple.Node(10), W: 1},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(2), W: 1},
 					{F: simple.Node(6), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(7), W: math.Inf(1)},
@@ -325,7 +325,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(13), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(13), T: simple.Node(14), W: math.Inf(1)},
 					{F: simple.Node(14), T: simple.Node(13), W: math.Inf(1)},
@@ -333,7 +333,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(15), T: simple.Node(11), W: math.Inf(1)},
 					{F: simple.Node(15), T: simple.Node(14), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(10), T: simple.Node(6), W: 1},
 					{F: simple.Node(10), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(11), W: math.Inf(1)},
@@ -358,7 +358,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
@@ -378,7 +378,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(3), T: simple.Node(2), W: math.Inf(1)},
 					{F: simple.Node(3), T: simple.Node(7), W: math.Inf(1)},
@@ -386,7 +386,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(7), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(7), T: simple.Node(6), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
@@ -401,7 +401,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(10), W: 1},
 					{F: simple.Node(7), T: simple.Node(11), W: math.Inf(1)},
@@ -413,7 +413,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(11), T: simple.Node(7), W: math.Inf(1)},
 					{F: simple.Node(11), T: simple.Node(10), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
@@ -434,7 +434,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(14), W: 1},
 					{F: simple.Node(11), T: simple.Node(15), W: math.Inf(1)},
@@ -446,7 +446,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(15), T: simple.Node(11), W: math.Inf(1)},
 					{F: simple.Node(15), T: simple.Node(14), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(6), W: math.Inf(1)},
@@ -470,7 +470,7 @@ var limitedVisionTests = []struct {
 			{
 				n:   node(14),
 				new: nil,
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(13), W: math.Inf(1)},
@@ -507,7 +507,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
@@ -523,7 +523,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(6), W: math.Sqrt2},
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
@@ -539,7 +539,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(6), W: 1},
 					{F: simple.Node(2), T: simple.Node(7), W: math.Inf(1)},
@@ -561,7 +561,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(10), W: 1},
 					{F: simple.Node(6), T: simple.Node(11), W: math.Inf(1)},
@@ -583,7 +583,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(10), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(14), W: 1},
 					{F: simple.Node(10), T: simple.Node(15), W: math.Inf(1)},
@@ -614,7 +614,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(5), W: math.Inf(1)},
@@ -642,7 +642,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(6), W: math.Sqrt2},
@@ -670,7 +670,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(6), W: math.Sqrt2},
@@ -716,7 +716,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(6), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(10), W: math.Inf(1)},
@@ -762,7 +762,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(14), W: math.Inf(1)},
@@ -805,7 +805,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
@@ -821,7 +821,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(6), W: math.Sqrt2},
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(6), W: 1},
@@ -832,7 +832,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(6), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(5), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(5), W: math.Inf(1)},
@@ -842,7 +842,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(7), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(7), W: math.Inf(1)},
@@ -855,7 +855,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(10), T: simple.Node(6), W: 1},
 					{F: simple.Node(10), T: simple.Node(7), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(1), W: 1},
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(5), W: math.Inf(1)},
@@ -872,7 +872,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(11), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(5), W: math.Inf(1)},
@@ -890,7 +890,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(14), T: simple.Node(10), W: 1},
 					{F: simple.Node(14), T: simple.Node(11), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(6), T: simple.Node(1), W: math.Sqrt2},
 					{F: simple.Node(6), T: simple.Node(2), W: 1},
 					{F: simple.Node(6), T: simple.Node(3), W: math.Inf(1)},
@@ -904,7 +904,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(14),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(10), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(15), W: math.Inf(1)},
 					{F: simple.Node(13), T: simple.Node(9), W: math.Inf(1)},
@@ -916,7 +916,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(15), T: simple.Node(11), W: math.Inf(1)},
 					{F: simple.Node(15), T: simple.Node(14), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(10), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(6), W: 1},
 					{F: simple.Node(10), T: simple.Node(7), W: math.Inf(1)},
@@ -945,7 +945,7 @@ var limitedVisionTests = []struct {
 		want: []changes{
 			{
 				n: node(1),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(0), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(0), T: simple.Node(5), W: math.Inf(1)},
@@ -973,7 +973,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(2),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(2), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(2), T: simple.Node(7), W: math.Inf(1)},
 					{F: simple.Node(3), T: simple.Node(2), W: math.Inf(1)},
@@ -985,7 +985,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(7), T: simple.Node(3), W: math.Inf(1)},
 					{F: simple.Node(7), T: simple.Node(6), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(4), W: math.Inf(1)},
@@ -1006,7 +1006,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(6),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(9), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(10), W: math.Inf(1)},
 					{F: simple.Node(6), T: simple.Node(9), W: math.Inf(1)},
@@ -1027,7 +1027,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(11), T: simple.Node(7), W: math.Inf(1)},
 					{F: simple.Node(11), T: simple.Node(10), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(1), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(1), T: simple.Node(2), W: 1},
 					{F: simple.Node(1), T: simple.Node(4), W: math.Inf(1)},
@@ -1058,7 +1058,7 @@ var limitedVisionTests = []struct {
 			},
 			{
 				n: node(10),
-				new: []simple.Edge{
+				new: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(13), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(14), W: math.Inf(1)},
 					{F: simple.Node(10), T: simple.Node(13), W: math.Inf(1)},
@@ -1078,7 +1078,7 @@ var limitedVisionTests = []struct {
 					{F: simple.Node(15), T: simple.Node(11), W: math.Inf(1)},
 					{F: simple.Node(15), T: simple.Node(14), W: math.Inf(1)},
 				},
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(5), T: simple.Node(0), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(1), W: math.Inf(1)},
 					{F: simple.Node(5), T: simple.Node(2), W: math.Inf(1)},
@@ -1116,7 +1116,7 @@ var limitedVisionTests = []struct {
 			{
 				n:   node(14),
 				new: nil,
-				old: []simple.Edge{
+				old: []simple.WeightedEdge{
 					{F: simple.Node(9), T: simple.Node(4), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(5), W: math.Inf(1)},
 					{F: simple.Node(9), T: simple.Node(6), W: math.Inf(1)},
@@ -1197,11 +1197,11 @@ func TestLimitedVisionGrid(t *testing.T) {
 	}
 }
 
-func asConcreteEdges(changes []graph.Edge, in graph.Weighted) []simple.Edge {
+func asConcreteEdges(changes []graph.Edge, in graph.Weighted) []simple.WeightedEdge {
 	if changes == nil {
 		return nil
 	}
-	we := make([]simple.Edge, len(changes))
+	we := make([]simple.WeightedEdge, len(changes))
 	for i, e := range changes {
 		we[i].F = e.From()
 		we[i].T = e.To()

graph/path/internal/testgraphs/shortest.go

@@ -26,7 +26,7 @@ func init() {
 var ShortestPathTests = []struct {
 	Name              string
 	Graph             func() graph.WeightedEdgeAdder
-	Edges             []simple.Edge
+	Edges             []simple.WeightedEdge
 	HasNegativeWeight bool
 	HasNegativeCycle  bool
 
@@ -59,7 +59,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "one edge directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 		},
 
@@ -75,7 +75,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "one edge self directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 		},
 
@@ -91,7 +91,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "one edge undirected",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 		},
 
@@ -107,7 +107,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "two paths directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(2), W: 2},
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -126,7 +126,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "two paths undirected",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(2), W: 2},
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -145,7 +145,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "confounding paths directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->5 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -179,7 +179,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "confounding paths undirected",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->5 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -213,7 +213,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "confounding paths directed 2-step",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->5 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -248,7 +248,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "confounding paths undirected 2-step",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->5 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -283,7 +283,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight cycle directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -307,7 +307,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight cycle^2 directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -334,7 +334,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight cycle^2 confounding directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -364,7 +364,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight cycle^3 directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -394,7 +394,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight 3·cycle^2 confounding directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -430,7 +430,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight reversed 3·cycle^2 confounding directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			// Add a path from 0->4 of weight 4
 			{F: simple.Node(0), T: simple.Node(1), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -466,8 +466,8 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight |V|·cycle^(n/|V|) directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: func() []simple.Edge {
+		Edges: func() []simple.WeightedEdge {
-			e := []simple.Edge{
+			e := []simple.WeightedEdge{
 				// Add a path from 0->4 of weight 4
 				{F: simple.Node(0), T: simple.Node(1), W: 1},
 				{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -480,8 +480,8 @@ var ShortestPathTests = []struct {
 			const n = 100
 			for i := 0; i < n; i++ {
 				e = append(e,
-					simple.Edge{F: simple.Node(next + i), T: simple.Node(i), W: 0},
+					simple.WeightedEdge{F: simple.Node(next + i), T: simple.Node(i), W: 0},
-					simple.Edge{F: simple.Node(i), T: simple.Node(next + i), W: 0},
+					simple.WeightedEdge{F: simple.Node(i), T: simple.Node(next + i), W: 0},
 				)
 			}
 			return e
@@ -499,8 +499,8 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight n·cycle directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: func() []simple.Edge {
+		Edges: func() []simple.WeightedEdge {
-			e := []simple.Edge{
+			e := []simple.WeightedEdge{
 				// Add a path from 0->4 of weight 4
 				{F: simple.Node(0), T: simple.Node(1), W: 1},
 				{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -513,8 +513,8 @@ var ShortestPathTests = []struct {
 			const n = 100
 			for i := 0; i < n; i++ {
 				e = append(e,
-					simple.Edge{F: simple.Node(next + i), T: simple.Node(1), W: 0},
+					simple.WeightedEdge{F: simple.Node(next + i), T: simple.Node(1), W: 0},
-					simple.Edge{F: simple.Node(1), T: simple.Node(next + i), W: 0},
+					simple.WeightedEdge{F: simple.Node(1), T: simple.Node(next + i), W: 0},
 				)
 			}
 			return e
@@ -532,8 +532,8 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "zero-weight bi-directional tree with single exit directed",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: func() []simple.Edge {
+		Edges: func() []simple.WeightedEdge {
-			e := []simple.Edge{
+			e := []simple.WeightedEdge{
 				// Add a path from 0->4 of weight 4
 				{F: simple.Node(0), T: simple.Node(1), W: 1},
 				{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -555,13 +555,13 @@ var ShortestPathTests = []struct {
 			for l := 0; l < depth; l++ {
 				for i = 0; i < branching; i++ {
 					last = next + i
-					e = append(e, simple.Edge{F: simple.Node(src), T: simple.Node(last), W: 0})
+					e = append(e, simple.WeightedEdge{F: simple.Node(src), T: simple.Node(last), W: 0})
-					e = append(e, simple.Edge{F: simple.Node(last), T: simple.Node(src), W: 0})
+					e = append(e, simple.WeightedEdge{F: simple.Node(last), T: simple.Node(src), W: 0})
 				}
 				src = next + 1
 				next += branching
 			}
-			e = append(e, simple.Edge{F: simple.Node(last), T: simple.Node(4), W: 2})
+			e = append(e, simple.WeightedEdge{F: simple.Node(last), T: simple.Node(4), W: 2})
 			return e
 		}(),
 
@@ -580,7 +580,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "one edge directed negative",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: -1},
 		},
 		HasNegativeWeight: true,
@@ -597,7 +597,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "one edge undirected negative",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: -1},
 		},
 		HasNegativeWeight: true,
@@ -608,7 +608,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "wp graph negative", // http://en.wikipedia.org/w/index.php?title=Johnson%27s_algorithm&oldid=564595231
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node('w'), T: simple.Node('z'), W: 2},
 			{F: simple.Node('x'), T: simple.Node('w'), W: 6},
 			{F: simple.Node('x'), T: simple.Node('y'), W: 3},
@@ -631,7 +631,7 @@ var ShortestPathTests = []struct {
 	{
 		Name:  "roughgarden negative",
 		Graph: func() graph.WeightedEdgeAdder { return simple.NewWeightedDirectedGraph(0, math.Inf(1)) },
-		Edges: []simple.Edge{
+		Edges: []simple.WeightedEdge{
 			{F: simple.Node('a'), T: simple.Node('b'), W: -2},
 			{F: simple.Node('b'), T: simple.Node('c'), W: -1},
 			{F: simple.Node('c'), T: simple.Node('a'), W: 4},

graph/path/spanning_tree.go

@@ -27,10 +27,10 @@ func Prim(dst graph.UndirectedBuilder, g graph.WeightedUndirected) float64 {
 
 	q := &primQueue{
 		indexOf: make(map[int64]int, len(nodes)-1),
-		nodes:   make([]simple.Edge, 0, len(nodes)-1),
+		nodes:   make([]simple.WeightedEdge, 0, len(nodes)-1),
 	}
 	for _, u := range nodes[1:] {
-		heap.Push(q, simple.Edge{F: u, W: math.Inf(1)})
+		heap.Push(q, simple.WeightedEdge{F: u, W: math.Inf(1)})
 	}
 
 	u := nodes[0]
@@ -44,7 +44,7 @@ func Prim(dst graph.UndirectedBuilder, g graph.WeightedUndirected) float64 {
 
 	var w float64
 	for q.Len() > 0 {
-		e := heap.Pop(q).(simple.Edge)
+		e := heap.Pop(q).(simple.WeightedEdge)
 		if e.To() != nil && g.HasEdgeBetween(e.From(), e.To()) {
 			dst.SetEdge(e)
 			w += e.Weight()
@@ -72,7 +72,7 @@ func Prim(dst graph.UndirectedBuilder, g graph.WeightedUndirected) float64 {
 // spanning forest.
 type primQueue struct {
 	indexOf map[int64]int
-	nodes   []simple.Edge
+	nodes   []simple.WeightedEdge
 }
 
 func (q *primQueue) Less(i, j int) bool {
@@ -90,7 +90,7 @@ func (q *primQueue) Len() int {
 }
 
 func (q *primQueue) Push(x interface{}) {
-	n := x.(simple.Edge)
+	n := x.(simple.WeightedEdge)
 	q.indexOf[n.From().ID()] = len(q.nodes)
 	q.nodes = append(q.nodes, n)
 }
@@ -141,7 +141,7 @@ type UndirectedWeightLister interface {
 // spanning tree weights will be returned.
 func Kruskal(dst graph.UndirectedBuilder, g UndirectedWeightLister) float64 {
 	edges := g.Edges()
-	ascend := make([]simple.Edge, 0, len(edges))
+	ascend := make([]simple.WeightedEdge, 0, len(edges))
 	for _, e := range edges {
 		u := e.From()
 		v := e.To()
@@ -149,7 +149,7 @@ func Kruskal(dst graph.UndirectedBuilder, g UndirectedWeightLister) float64 {
 		if !ok {
 			panic("kruskal: unexpected invalid weight")
 		}
-		ascend = append(ascend, simple.Edge{F: u, T: v, W: w})
+		ascend = append(ascend, simple.WeightedEdge{F: u, T: v, W: w})
 	}
 	sort.Sort(byWeight(ascend))
 
@@ -169,7 +169,7 @@ func Kruskal(dst graph.UndirectedBuilder, g UndirectedWeightLister) float64 {
 	return w
 }
 
-type byWeight []simple.Edge
+type byWeight []simple.WeightedEdge
 
 func (e byWeight) Len() int           { return len(e) }
 func (e byWeight) Less(i, j int) bool { return e[i].Weight() < e[j].Weight() }

graph/path/spanning_tree_test.go

@@ -34,9 +34,9 @@ type spanningGraph interface {
 var spanningTreeTests = []struct {
 	name      string
 	graph     func() spanningGraph
-	edges     []simple.Edge
+	edges     []simple.WeightedEdge
 	want      float64
-	treeEdges []simple.Edge
+	treeEdges []simple.WeightedEdge
 }{
 	{
 		name:  "Empty",
@@ -49,7 +49,7 @@ var spanningTreeTests = []struct {
 		// to prevent the alternative solution being found.
 		name:  "Prim WP figure 1",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('B'), W: 2.5},
 			{F: simple.Node('A'), T: simple.Node('D'), W: 1},
 			{F: simple.Node('B'), T: simple.Node('D'), W: 2},
@@ -57,7 +57,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 6,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('D'), W: 1},
 			{F: simple.Node('B'), T: simple.Node('D'), W: 2},
 			{F: simple.Node('C'), T: simple.Node('D'), W: 3},
@@ -67,7 +67,7 @@ var spanningTreeTests = []struct {
 		// https://upload.wikimedia.org/wikipedia/commons/5/5c/MST_kruskal_en.gif
 		name:  "Kruskal WP figure 1",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node('a'), T: simple.Node('b'), W: 3},
 			{F: simple.Node('a'), T: simple.Node('e'), W: 1},
 			{F: simple.Node('b'), T: simple.Node('c'), W: 5},
@@ -78,7 +78,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 11,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node('a'), T: simple.Node('b'), W: 3},
 			{F: simple.Node('a'), T: simple.Node('e'), W: 1},
 			{F: simple.Node('b'), T: simple.Node('c'), W: 5},
@@ -89,7 +89,7 @@ var spanningTreeTests = []struct {
 		// https://upload.wikimedia.org/wikipedia/commons/8/87/Kruskal_Algorithm_6.svg
 		name:  "Kruskal WP example",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('B'), W: 7},
 			{F: simple.Node('A'), T: simple.Node('D'), W: 5},
 			{F: simple.Node('B'), T: simple.Node('C'), W: 8},
@@ -104,7 +104,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 39,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('B'), W: 7},
 			{F: simple.Node('A'), T: simple.Node('D'), W: 5},
 			{F: simple.Node('B'), T: simple.Node('E'), W: 7},
@@ -117,7 +117,7 @@ var spanningTreeTests = []struct {
 		// https://upload.wikimedia.org/wikipedia/commons/2/2e/Boruvka%27s_algorithm_%28Sollin%27s_algorithm%29_Anim.gif
 		name:  "Borůvka WP example",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('B'), W: 13},
 			{F: simple.Node('A'), T: simple.Node('C'), W: 6},
 			{F: simple.Node('B'), T: simple.Node('C'), W: 7},
@@ -141,7 +141,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 83,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('C'), W: 6},
 			{F: simple.Node('B'), T: simple.Node('C'), W: 7},
 			{F: simple.Node('B'), T: simple.Node('D'), W: 1},
@@ -160,7 +160,7 @@ var spanningTreeTests = []struct {
 		// Nodes labelled row major.
 		name:  "Minimum Spanning Tree WP figure 1",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(1), T: simple.Node(2), W: 4},
 			{F: simple.Node(1), T: simple.Node(3), W: 1},
 			{F: simple.Node(1), T: simple.Node(4), W: 4},
@@ -185,7 +185,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 38,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node(1), T: simple.Node(2), W: 4},
 			{F: simple.Node(1), T: simple.Node(3), W: 1},
 			{F: simple.Node(2), T: simple.Node(8), W: 7},
@@ -203,7 +203,7 @@ var spanningTreeTests = []struct {
 		// but with C--H and E--J cut.
 		name:  "Borůvka WP example cut",
 		graph: func() spanningGraph { return simple.NewWeightedUndirectedGraph(0, math.Inf(1)) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('B'), W: 13},
 			{F: simple.Node('A'), T: simple.Node('C'), W: 6},
 			{F: simple.Node('B'), T: simple.Node('C'), W: 7},
@@ -225,7 +225,7 @@ var spanningTreeTests = []struct {
 		},
 
 		want: 65,
-		treeEdges: []simple.Edge{
+		treeEdges: []simple.WeightedEdge{
 			{F: simple.Node('A'), T: simple.Node('C'), W: 6},
 			{F: simple.Node('B'), T: simple.Node('C'), W: 7},
 			{F: simple.Node('B'), T: simple.Node('D'), W: 1},

graph/simple/dense_directed_matrix.go

@@ -109,7 +109,7 @@ func (g *DirectedMatrix) Edges() []graph.Edge {
 				continue
 			}
 			if w := g.mat.At(i, j); !isSame(w, g.absent) {
-				edges = append(edges, Edge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
+				edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
 			}
 		}
 	}
@@ -182,7 +182,7 @@ func (g *DirectedMatrix) Edge(u, v graph.Node) graph.Edge {
 func (g *DirectedMatrix) WeightedEdge(u, v graph.Node) graph.WeightedEdge {
 	if g.HasEdgeFromTo(u, v) {
 		// x.ID() and y.ID() are not greater than maximum int by this point.
-		return Edge{F: g.Node(u.ID()), T: g.Node(v.ID()), W: g.mat.At(int(u.ID()), int(v.ID()))}
+		return WeightedEdge{F: g.Node(u.ID()), T: g.Node(v.ID()), W: g.mat.At(int(u.ID()), int(v.ID()))}
 	}
 	return nil
 }

graph/simple/dense_undirected_matrix.go

@@ -106,7 +106,7 @@ func (g *UndirectedMatrix) Edges() []graph.Edge {
 	for i := 0; i < r; i++ {
 		for j := i + 1; j < r; j++ {
 			if w := g.mat.At(i, j); !isSame(w, g.absent) {
-				edges = append(edges, Edge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
+				edges = append(edges, WeightedEdge{F: g.Node(int64(i)), T: g.Node(int64(j)), W: w})
 			}
 		}
 	}
@@ -168,7 +168,7 @@ func (g *UndirectedMatrix) EdgeBetween(u, v graph.Node) graph.Edge {
 func (g *UndirectedMatrix) WeightedEdgeBetween(u, v graph.Node) graph.WeightedEdge {
 	if g.HasEdgeBetween(u, v) {
 		// u.ID() and v.ID() are not greater than maximum int by this point.
-		return Edge{F: g.Node(u.ID()), T: g.Node(v.ID()), W: g.mat.At(int(u.ID()), int(v.ID()))}
+		return WeightedEdge{F: g.Node(u.ID()), T: g.Node(v.ID()), W: g.mat.At(int(u.ID()), int(v.ID()))}
 	}
 	return nil
 }

graph/simple/densegraph_test.go

@@ -75,7 +75,7 @@ func TestBasicDensePassable(t *testing.T) {
 
 func TestDirectedDenseAddRemove(t *testing.T) {
 	dg := NewDirectedMatrix(10, math.Inf(1), 0, math.Inf(1))
-	dg.SetEdge(Edge{F: Node(0), T: Node(2), W: 1})
+	dg.SetWeightedEdge(WeightedEdge{F: Node(0), T: Node(2), W: 1})
 
 	if neighbors := dg.From(Node(0)); len(neighbors) != 1 || neighbors[0].ID() != 2 ||
 		dg.Edge(Node(0), Node(2)) == nil {
@@ -92,7 +92,7 @@ func TestDirectedDenseAddRemove(t *testing.T) {
 		t.Errorf("Removing directed edge wrongly kept predecessor")
 	}
 
-	dg.SetEdge(Edge{F: Node(0), T: Node(2), W: 2})
+	dg.SetWeightedEdge(WeightedEdge{F: Node(0), T: Node(2), W: 2})
 	// I figure we've torture tested From/To at this point
 	// so we'll just use the bool functions now
 	if dg.Edge(Node(0), Node(2)) == nil {

graph/simple/simple.go

@@ -22,7 +22,6 @@ func (n Node) ID() int64 {
 // Edge is a simple graph edge.
 type Edge struct {
 	F, T graph.Node
-	W    float64
 }
 
 // From returns the from-node of the edge.
@@ -31,8 +30,20 @@ func (e Edge) From() graph.Node { return e.F }
 // To returns the to-node of the edge.
 func (e Edge) To() graph.Node { return e.T }
 
+// WeightedEdge is a simple weighted graph edge.
+type WeightedEdge struct {
+	F, T graph.Node
+	W    float64
+}
+
+// From returns the from-node of the edge.
+func (e WeightedEdge) From() graph.Node { return e.F }
+
+// To returns the to-node of the edge.
+func (e WeightedEdge) To() graph.Node { return e.T }
+
 // Weight returns the weight of the edge.
-func (e Edge) Weight() float64 { return e.W }
+func (e WeightedEdge) Weight() float64 { return e.W }
 
 // isSame returns whether two float64 values are the same where NaN values
 // are equalable.

graph/simple/weighted_directed.go

@@ -82,7 +82,7 @@ func (g *WeightedDirectedGraph) RemoveNode(n graph.Node) {
 
 // NewWeightedEdge returns a new weighted edge from the source to the destination node.
 func (g *WeightedDirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge {
-	return &Edge{F: from, T: to, W: weight}
+	return &WeightedEdge{F: from, T: to, W: weight}
 }
 
 // SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added.

graph/simple/weighted_directed_test.go

@@ -39,7 +39,7 @@ func generateDummyWeightedGraph() *WeightedDirectedGraph {
 	g := NewWeightedDirectedGraph(0, math.Inf(1))
 
 	for _, n := range nodes {
-		g.SetWeightedEdge(Edge{F: Node(n.srcID), T: Node(n.targetID), W: 1})
+		g.SetWeightedEdge(WeightedEdge{F: Node(n.srcID), T: Node(n.targetID), W: 1})
 	}
 
 	return g

graph/simple/weighted_undirected.go

@@ -74,7 +74,7 @@ func (g *WeightedUndirectedGraph) RemoveNode(n graph.Node) {
 
 // NewWeightedEdge returns a new weighted edge from the source to the destination node.
 func (g *WeightedUndirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge {
-	return &Edge{F: from, T: to, W: weight}
+	return &WeightedEdge{F: from, T: to, W: weight}
 }
 
 // SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added.

graph/undirect_test.go

@@ -22,7 +22,7 @@ var weightedDirectedGraphs = []struct {
 	skipUnweighted bool
 
 	g      func() weightedDirectedBuilder
-	edges  []simple.Edge
+	edges  []simple.WeightedEdge
 	absent float64
 	merge  func(x, y float64, xe, ye graph.Edge) float64
 
@@ -30,7 +30,7 @@ var weightedDirectedGraphs = []struct {
 }{
 	{
 		g: func() weightedDirectedBuilder { return simple.NewWeightedDirectedGraph(0, 0) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 2},
 			{F: simple.Node(1), T: simple.Node(0), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -43,7 +43,7 @@ var weightedDirectedGraphs = []struct {
 	},
 	{
 		g: func() weightedDirectedBuilder { return simple.NewWeightedDirectedGraph(0, 0) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 2},
 			{F: simple.Node(1), T: simple.Node(0), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -60,7 +60,7 @@ var weightedDirectedGraphs = []struct {
 		skipUnweighted: true, // The min merge function cannot be used in the unweighted case.
 
 		g: func() weightedDirectedBuilder { return simple.NewWeightedDirectedGraph(0, 0) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 2},
 			{F: simple.Node(1), T: simple.Node(0), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -74,7 +74,7 @@ var weightedDirectedGraphs = []struct {
 	},
 	{
 		g: func() weightedDirectedBuilder { return simple.NewWeightedDirectedGraph(0, 0) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 2},
 			{F: simple.Node(1), T: simple.Node(0), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},
@@ -96,7 +96,7 @@ var weightedDirectedGraphs = []struct {
 	},
 	{
 		g: func() weightedDirectedBuilder { return simple.NewWeightedDirectedGraph(0, 0) },
-		edges: []simple.Edge{
+		edges: []simple.WeightedEdge{
 			{F: simple.Node(0), T: simple.Node(1), W: 2},
 			{F: simple.Node(1), T: simple.Node(0), W: 1},
 			{F: simple.Node(1), T: simple.Node(2), W: 1},