now working

Author: sbromberger

src/StaticGraphs.jl

@@ -40,9 +40,8 @@ export
 
 include("utils.jl")
 
-const StaticEdgeIter{G} = LightGraphs.SimpleGraphs.SimpleEdgeIter{G}
-const AbstractStaticEdge = AbstractSimpleEdge
-const StaticEdge = SimpleEdge
+const AbstractStaticEdge{T} = AbstractSimpleEdge{T}
+const StaticEdge{T} = SimpleEdge{T}
 
 """
     AbstractStaticGraph
@@ -86,9 +85,9 @@ vertices(g::AbstractStaticGraph{T, U}) where T where U = one(T):nv(g)
 
 
 has_edge(g::AbstractStaticGraph, e::AbstractStaticEdge) =
-    insorted(dst(e), neighbors(g, src(e)))
+    insorted(dst(e), out_neighbors(g, src(e)))
 
-edgetype(g::AbstractStaticGraph) = StaticEdge
+edgetype(g::AbstractStaticGraph{T}) where T = StaticEdge{T}
 edges(g::AbstractStaticGraph) = StaticEdgeIter(g)
 
 has_vertex(g::AbstractStaticGraph, v::Integer) = v in vertices(g)
@@ -109,4 +108,10 @@ include("persistence.jl")
 const SGraph = StaticGraph
 const SDiGraph = StaticDiGraph
 
+const StaticEdgeIter{G} = LightGraphs.SimpleGraphs.SimpleEdgeIter{G}
+
+eltype(::Type{StaticEdgeIter{StaticGraph{T, U}}}) where T where U = StaticGraphEdge{T}
+eltype(::Type{StaticEdgeIter{StaticDiGraph{T, U}}}) where T where U = StaticDiGraphEdge{T}
+
+
 end # module

src/persistence.jl

@@ -30,8 +30,8 @@ end
 
 function loadsg(fn::AbstractString, ::SDGFormat)
     @load fn f_vec f_ind b_vec b_ind
-    return StaticGraph(f_vec, f_ind, b_vec, b_ind)
+    return StaticDiGraph(f_vec, f_ind, b_vec, b_ind)
 end
 
-loadgraph(fn::AbstractString, gname::String) = loadsg(fn, s)
+loadgraph(fn::AbstractString, gname::String, s::StaticGraphFormat) = loadsg(fn, s)
 savegraph(fn::AbstractString, g::AbstractStaticGraph) =  savesg(fn, g)

src/staticdigraph.jl

@@ -33,11 +33,11 @@ function StaticDiGraph(n_v, f_ss::AbstractVector, f_ds::AbstractVector, b_ss::Ab
     push!(b_ind, length(b_ss)+1)
     T = mintype(f_ds)
     U = mintype(f_ind)
-    return StaticDiGraph{T}(
-        convert(T, f_ds), 
-        convert(U, f_ind), 
-        convert(T, b_ds),
-        convert(U, b_ind)
+    return StaticDiGraph{T, U}(
+        convert(Vector{T}, f_ds), 
+        convert(Vector{U}, f_ind), 
+        convert(Vector{T}, b_ds),
+        convert(Vector{U}, b_ind)
     )
 end
 

src/staticgraph.jl

@@ -10,10 +10,6 @@ struct StaticGraph{T<:Integer, U<:Integer} <: AbstractStaticGraph{T, U}
     f_ind::Vector{U}
 end
 
-badj(g::StaticGraph, s) = fadj(g, s)
-
-ne(g::StaticGraph{T, U}) where T where U = T(length(g.f_vec) ÷ 2)
-
 
 # sorted src, dst vectors
 # note: this requires reverse edges included in the sorted vector.  
@@ -42,6 +38,18 @@ function StaticGraph(g::LightGraphs.SimpleGraphs.SimpleGraph)
     StaticGraph(nv(g), sd)
 end
 
+badj(g::StaticGraph, s) = fadj(g, s)
+
+ne(g::StaticGraph{T, U}) where T where U = T(length(g.f_vec) ÷ 2)
+
+function has_edge(g::StaticGraph, e::StaticGraphEdge)
+    u, v = Tuple(e)
+    (u > nv(g) || v > nv(g)) && return false
+    if degree(g, u) > degree(g, v)
+        u, v = v, u
+    end
+    return insorted(v, fadj(g, u))
+end
 ==(g::StaticGraph, h::StaticGraph) = g.f_vec == h.f_vec && g.f_ind == h.f_ind
 
 degree(g::StaticGraph{T, U}, v::Integer) where T where U = T(length(_fvrange(g, v)))

test/runtests.jl

@@ -8,28 +8,24 @@ const testdir = dirname(@__FILE__)
 
 @testset "StaticGraphs" begin
 
-    h = loadgraph(joinpath(testdir, "testdata", "house.jsg"), SGFormat())
-    hu = loadgraph(joinpath(testdir, "testdata", "house-uint8.jsg"), SGFormat(UInt8))
-    dh = loadgraph(joinpath(testdir, "testdata", "pathdg.jsg"), SDGFormat())
-    dhu = loadgraph(joinpath(testdir, "testdata", "pathdg-uint8.jsg"), SDGFormat(UInt8))
+    hu = loadgraph(joinpath(testdir, "testdata", "house-uint8.jsg"), SGFormat())
+    dhu = loadgraph(joinpath(testdir, "testdata", "pathdg-uint8.jsg"), SDGFormat())
 
     @testset "staticgraph" begin
-        @test sprint(show, StaticGraph(Graph())) == "empty undirected simple static Int64 graph"
+        @test sprint(show, StaticGraph(Graph())) == "empty undirected simple static {UInt8, UInt8} graph"
         g = smallgraph(:house)
         gu = squash(g)
         sg = StaticGraph(g)
         sgu = StaticGraph(gu)
-        @test sprint(show, sg) == "{5, 6} undirected simple static Int64 graph"
-        @test sprint(show, sgu) == "{5, 6} undirected simple static UInt8 graph"
+        @test sprint(show, sg) == "{5, 6} undirected simple static {UInt8, UInt8} graph"
+        @test sprint(show, sgu) == "{5, 6} undirected simple static {UInt8, UInt8} graph"
         testfn(fn, args...) =
-            @inferred(fn(h, args...)) == 
             @inferred(fn(hu, args...)) == 
             @inferred(fn(sg, args...)) == 
             @inferred(fn(sgu, args...)) == 
             fn(g, args...)
 
-        @test h == sg
-        @test hu == sgu
+        @test hu == sg == sgu
         @test @inferred eltype(hu) == UInt8
         @test testfn(ne)
         @test testfn(nv)
@@ -49,31 +45,27 @@ const testdir = dirname(@__FILE__)
         @test @inferred has_vertex(hu, 1)
         @test @inferred !has_vertex(hu, 10)
         @test @inferred !is_directed(hu)
-        @test @inferred !is_directed(h)
         @test @inferred !is_directed(StaticGraph)
-        @test @inferred collect(edges(h)) == collect(edges(sg))
+        @test @inferred collect(edges(hu)) == collect(edges(sg))
     end # staticgraph
 
     @testset "staticdigraph" begin
-        @test sprint(show, StaticDiGraph(DiGraph())) == "empty directed simple static Int64 graph"
+        @test sprint(show, StaticDiGraph(DiGraph())) == "empty directed simple static {UInt8, UInt8} graph"
         dg = PathDiGraph(5)
         dgu = squash(dg)
         dsg = StaticDiGraph(dg)
         dsgu = StaticDiGraph(dgu)
-        @test sprint(show, dsg) == "{5, 4} directed simple static Int64 graph"
-        @test sprint(show, dsgu) == "{5, 4} directed simple static UInt8 graph"
-        dh = loadgraph(joinpath(testdir, "testdata", "pathdg.jsg"), SDGFormat())
-        dhu = loadgraph(joinpath(testdir, "testdata", "pathdg-uint8.jsg"), SDGFormat(UInt8))
+        @test sprint(show, dsg) == "{5, 4} directed simple static {UInt8, UInt8} graph"
+        @test sprint(show, dsgu) == "{5, 4} directed simple static {UInt8, UInt8} graph"
+        dhu = loadgraph(joinpath(testdir, "testdata", "pathdg-uint8.jsg"), SDGFormat())
 
         dtestfn(fn, args...) =
-            @inferred(fn(dh, args...)) == 
             @inferred(fn(dhu, args...)) == 
             @inferred(fn(dsg, args...)) == 
             @inferred(fn(dsgu, args...)) == 
             fn(dg, args...)
 
-        @test dh == dsg
-        @test dhu == dsgu
+        @test dhu == dsg == dsgu
         @test @inferred eltype(dhu) == UInt8
         @test dtestfn(ne)
         @test dtestfn(nv)
@@ -93,9 +85,8 @@ const testdir = dirname(@__FILE__)
         @test @inferred has_vertex(dhu, 1)
         @test @inferred !has_vertex(dhu, 10)
         @test @inferred is_directed(dhu)
-        @test @inferred is_directed(dh)
         @test @inferred is_directed(StaticDiGraph)
-        @test @inferred collect(edges(dh)) == collect(edges(dsg))
+        @test @inferred collect(edges(dhu)) == collect(edges(dsg))
     end # staticdigraph
 
     @testset "utils" begin
@@ -110,9 +101,7 @@ const testdir = dirname(@__FILE__)
 
     @testset "persistence" begin
         function writegraphs(f, fio)
-            @test savegraph(f, h) == 1
             @test savegraph(f, hu) == 1
-            @test savegraph(f, dh) == 1
             @test savegraph(f, dhu) == 1
         end
         mktemp(writegraphs)