package/gonum
1
0
Fork 0
mirror of https://github.com/gonum/gonum.git synced 2025-10-08 08:30:14 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

graph/simple: separate weighted and unweighted edge implementations

Browse Source
This commit is contained in:
kortschak
2017-08-22 15:53:09 +09:30
parent 7ba61f0ead
commit f739fbf133
27 changed files with 192 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
graph/community/bisect_test.go
View File

@@ -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})
}
}

4
graph/community/louvain_directed_multiplex_test.go
View File

@@ -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)

12
graph/community/louvain_directed_test.go
View File

@@ -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},
} {

4
graph/community/louvain_undirected_multiplex_test.go
View File

@@ -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)

12
graph/community/louvain_undirected_test.go
View File

@@ -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},
} {

20
graph/graphs/gen/batagelj_brandes.go
View File

@@ -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)

6
graph/graphs/gen/holme_kim.go
View File

@@ -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]++
}

4
graph/graphs/gen/small_world.go
View File

@@ -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
}

4
graph/network/betweenness_test.go
View File

@@ -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})
}
}

4
graph/network/distance_test.go
View File

@@ -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)

4
graph/path/dynamic/dstarlite.go
View File

@@ -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)

10
graph/path/dynamic/dstarlite_test.go
View File

@@ -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.
func simpleEdgesOf(g graph.Weighted, edges []graph.Edge) []simple.Edge {
w := make([]simple.Edge, len(edges))
// simpleWeightedEdgesOf returns the weighted edges in g corresponding to the given edges.
func simpleWeightedEdgesOf(g graph.Weighted, edges []graph.Edge) []simple.WeightedEdge {
w := make([]simple.WeightedEdge, len(edges))
for i, e := range edges {
w[i].F = e.From()
w[i].T = e.To()

4
graph/path/dynamic/dumper_test.go
View File

@@ -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 {

4
graph/path/internal/grid.go
View File

@@ -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
}

4
graph/path/internal/limited.go
View File

@@ -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
}

114
graph/path/internal/limited_test.go
View File

@@ -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()

66
graph/path/internal/testgraphs/shortest.go
View File

@@ -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 {
e := []simple.Edge{
Edges: func() []simple.WeightedEdge {
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.Edge{F: simple.Node(i), T: simple.Node(next + i), W: 0},
simple.WeightedEdge{F: simple.Node(next + i), T: simple.Node(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 {
e := []simple.Edge{
Edges: func() []simple.WeightedEdge {
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.Edge{F: simple.Node(1), T: simple.Node(next + i), W: 0},
simple.WeightedEdge{F: simple.Node(next + i), T: simple.Node(1), 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 {
e := []simple.Edge{
Edges: func() []simple.WeightedEdge {
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.Edge{F: simple.Node(last), T: simple.Node(src), W: 0})
e = append(e, simple.WeightedEdge{F: simple.Node(src), T: simple.Node(last), 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},

16
graph/path/spanning_tree.go
View File

@@ -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() }

28
graph/path/spanning_tree_test.go
View File

@@ -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},

4
graph/simple/dense_directed_matrix.go
View File

@@ -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
}

4
graph/simple/dense_undirected_matrix.go
View File

@@ -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
}

4
graph/simple/densegraph_test.go
View File

@@ -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 {

15
graph/simple/simple.go
View File

@@ -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.

2
graph/simple/weighted_directed.go
View File

@@ -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.

2
graph/simple/weighted_directed_test.go
View File

@@ -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

2
graph/simple/weighted_undirected.go
View File

@@ -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.

12
graph/undirect_test.go
View File

@@ -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},