merge master

Author: matbesancon

.travis.yml

@@ -4,7 +4,7 @@ os:
   - linux
 #  - osx
 julia:
-  - 0.6
+  -1.0
   - nightly
 
 matrix:
@@ -29,4 +29,4 @@ git:
 #  - julia -e 'Pkg.clone(pwd()); Pkg.build("StaticGraphs"); Pkg.test("StaticGraphs"; coverage=true)'
 after_success:
   # push coverage results to Codecov
-  - julia -e 'cd(Pkg.dir("StaticGraphs")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
+  - julia -e 'using Pkg; cd(Pkg.dir("StaticGraphs")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'

REQUIRE

@@ -1,3 +1,3 @@
-julia 0.6
-LightGraphs 0.11
+julia 1.0
+LightGraphs 1.0
 JLD2

src/StaticGraphs.jl

@@ -4,13 +4,13 @@ using LightGraphs
 using JLD2
 
 import Base:
-    convert, eltype, show, ==, Pair, Tuple, in, copy, length, start, next, done, issubset, zero, one,
+    convert, eltype, show, ==, Pair, Tuple, in, copy, length, issubset, zero, one,
     size, getindex, setindex!, length, IndexStyle
 
 import LightGraphs:
-    _NI, _insert_and_dedup!, AbstractEdge, AbstractEdgeIter,
+    _NI, AbstractEdge, AbstractEdgeIter,
     src, dst, edgetype, nv, ne, vertices, edges, is_directed,
-    has_vertex, has_edge, in_neighbors, out_neighbors,
+    has_vertex, has_edge, inneighbors, outneighbors,
     indegree, outdegree, degree, insorted, squash,
 
     AbstractGraphFormat, loadgraph, savegraph
@@ -57,7 +57,7 @@ indtype(g::AbstractStaticGraph{T, U}) where T where U = U
 eltype(x::AbstractStaticGraph) = vectype(x)
 
 function show(io::IO, g::AbstractStaticGraph)
-    dir = is_directed(g)? "directed" : "undirected"
+    dir = is_directed(g) ? "directed" : "undirected"
     print(io, "{$(nv(g)), $(ne(g))} $dir simple static {$(vectype(g)), $(indtype(g))} graph")
 end
 
@@ -69,23 +69,22 @@ end
 
 @inline function fadj(g::AbstractStaticGraph, s::Integer)
     r = _fvrange(g, s)
-    return fastview(g.f_vec, r)
+    return view(g.f_vec, r)
 end
 
 nv(g::AbstractStaticGraph{T, U}) where T where U = T(length(g.f_ind) - 1)
 vertices(g::AbstractStaticGraph{T, U}) where T where U = one(T):nv(g)
 
-
 has_edge(g::AbstractStaticGraph, e::AbstractStaticEdge) =
-    insorted(dst(e), out_neighbors(g, src(e)))
+    insorted(dst(e), outneighbors(g, src(e)))
 
 edgetype(g::AbstractStaticGraph{T}) where T = StaticEdge{T}
 edges(g::AbstractStaticGraph) = StaticEdgeIter(g)
 
 has_vertex(g::AbstractStaticGraph, v::Integer) = v in vertices(g)
 
-out_neighbors(g::AbstractStaticGraph, v::Integer) = fadj(g, v)
-in_neighbors(g::AbstractStaticGraph, v::Integer) = badj(g, v)
+outneighbors(g::AbstractStaticGraph, v::Integer) = fadj(g, v)
+inneighbors(g::AbstractStaticGraph, v::Integer) = badj(g, v)
 
 zero(g::T) where T<:AbstractStaticGraph = T()
 
@@ -97,6 +96,7 @@ include("staticgraph.jl")
 include("staticdigraph.jl")
 include("persistence.jl")
 
+
 const SGraph = StaticGraph
 const SDiGraph = StaticDiGraph
 
@@ -105,5 +105,6 @@ 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}
 
+include("overrides.jl")
 
 end # module

src/overrides.jl

@@ -0,0 +1,7 @@
+function adjacency_matrix(g::StaticGraph)
+    SparseMatrixCSC{Bool,UInt32}(nv(g), nv(g), g.f_ind, g.f_vec, ones(Bool, ne(g)*2))
+end
+
+function adjacency_matrix(g::StaticDiGraph)
+    SparseMatrixCSC{Bool,UInt32}(nv(g), nv(g), g.f_ind, g.f_vec, ones(Bool, ne(g)))
+end

src/staticdigraph.jl

@@ -18,7 +18,7 @@ end
 
 @inline function badj(g::StaticDiGraph, s)
     r = _bvrange(g, s)
-    return fastview(g.b_vec, r)
+    return view(g.b_vec, r)
 end
 
 ne(g::StaticDiGraph{T, U}) where T where U = U(length(g.f_vec))
@@ -31,8 +31,8 @@ function StaticDiGraph(nvtx::I, f_ss::AbstractVector{F}, f_ds::AbstractVector{D}
     push!(f_ind, length(f_ss)+1)
     b_ind = [searchsortedfirst(b_ss, x) for x in 1:nvtx]
     push!(b_ind, length(b_ss)+1)
-    T = mintype(f_ds)
-    U = mintype(f_ind)
+    T = mintype(maximum(f_ds))
+    U = mintype(f_ind[end])
     return StaticDiGraph{T, U}(
         convert(Vector{T}, f_ds), 
         convert(Vector{U}, f_ind), 
@@ -52,6 +52,7 @@ function StaticDiGraph(nvtx::I, f_sd::Vector{Tuple{T, T}}, b_sd::Vector{Tuple{T,
 end
 
 function StaticDiGraph(g::LightGraphs.SimpleGraphs.SimpleDiGraph)
+    ne(g) == 0 && return StaticDiGraph(nv(g), Array{Tuple{UInt8, UInt8},1}(), Array{Tuple{UInt8, UInt8},1}())
     f_sd = [Tuple(e) for e in edges(g)]
     b_sd = sort([Tuple(reverse(e)) for e in edges(g)])
 
@@ -62,6 +63,15 @@ function StaticDiGraph()
     return StaticDiGraph(UInt8[], UInt8[1], UInt8[], UInt8[1])
 end
 
+function StaticDiGraph{T, U}(s::StaticDiGraph) where T <: Integer where U <: Integer
+    new_fvec = T.(s.f_vec)
+    new_find = U.(s.f_ind)
+    new_bvec = T.(s.b_vec)
+    new_bind = U.(s.b_ind)
+    return StaticDiGraph(new_fvec, new_find, new_bvec, new_bind)
+end
+
+
 ==(g::StaticDiGraph, h::StaticDiGraph) = g.f_vec == h.f_vec && g.f_ind == h.f_ind && g.b_vec == h.b_vec && g.b_ind == h.b_ind
 
 degree(g::StaticDiGraph, v::Integer) = indegree(g, v) + outdegree(g, v)
@@ -79,4 +89,5 @@ Return `true` if `g` is a directed graph.
 """
 is_directed(::Type{StaticDiGraph}) = true
 is_directed(::Type{StaticDiGraph{T}}) where T = true
+is_directed(::Type{StaticDiGraph{T, U}}) where T where U = true
 is_directed(g::StaticDiGraph) = true

src/staticgraph.jl

@@ -17,11 +17,17 @@ function StaticGraph(nvtx::I, ss::AbstractVector{S}, ds::AbstractVector{D}) wher
     (nvtx == 0 || length(ss) == 0) && return StaticGraph()
     f_ind = [searchsortedfirst(ss, x) for x in 1:nvtx]
     push!(f_ind, length(ss)+1)
-    T = mintype(ds)
-    U = mintype(f_ind)
+    T = mintype(maximum(ds))
+    U = mintype(f_ind[end])
     return StaticGraph{T, U}(convert(Vector{T},ds), convert(Vector{U}, f_ind))
 end
 
+function StaticGraph{T, U}(s::StaticGraph) where T <: Integer where U <: Integer
+    new_fvec = T.(s.f_vec)
+    new_find = U.(s.f_ind)
+    return StaticGraph(new_fvec, new_find)
+end
+
 # sorted src, dst tuples
 function StaticGraph(nvtx::I, sd::Vector{Tuple{T, T}}) where {T<:Integer, I<:Integer}
     ss = [x[1] for x in sd]
@@ -30,6 +36,7 @@ function StaticGraph(nvtx::I, sd::Vector{Tuple{T, T}}) where {T<:Integer, I<:Int
 end
 
 function StaticGraph(g::LightGraphs.SimpleGraphs.SimpleGraph)
+    ne(g) == 0 && return StaticGraph(nv(g), Array{Tuple{UInt8, UInt8},1}())
     sd1 = [Tuple(e) for e in edges(g)]
     ds1 = [Tuple(reverse(e)) for e in edges(g)]
     sd = sort(vcat(sd1, ds1))

src/utils.jl

@@ -29,18 +29,13 @@ end
 """
     mintype(v)
 
-Returns the minimum integer type required to fit all elements
-in sorted vector `v`.
-
-### Implementation Notes
-`v` is assumed to be sorted.
+Returns the minimum integer type required to represent integer `v`.
 """
-function mintype(v::AbstractVector)
+function mintype(v::T) where T <: Integer
     validtypes = [UInt8, UInt16, UInt32, UInt64, UInt128]
-    l = v[end]
-    for T in validtypes
-        l <= typemax(T) && return T
+    for U in validtypes
+        v <= typemax(U) && return U
     end
-    return eltype(v)
+    return T
 end
 

test/runtests.jl

@@ -1,7 +1,7 @@
 using StaticGraphs
 using LightGraphs
 using LightGraphs.SimpleGraphs
-using Base.Test
+using Test
 
 const testdir = dirname(@__FILE__)
 
@@ -19,6 +19,7 @@ const testdir = dirname(@__FILE__)
         sgu = StaticGraph(gu)
         gempty = StaticGraph()
         gdempty = StaticDiGraph()
+        @test eltype(StaticGraph{UInt128, UInt128}(sgu)) == UInt128
         @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...) =
@@ -31,8 +32,8 @@ const testdir = dirname(@__FILE__)
         @test @inferred eltype(hu) == UInt8
         @test testfn(ne)
         @test testfn(nv)
-        @test testfn(in_neighbors, 1)
-        @test testfn(out_neighbors, 1)
+        @test testfn(inneighbors, 1)
+        @test testfn(outneighbors, 1)
         @test testfn(vertices)
         @test testfn(degree)
         @test testfn(degree, 1)
@@ -65,6 +66,7 @@ const testdir = dirname(@__FILE__)
         dgu = squash(dg)
         dsg = StaticDiGraph(dg)
         dsgu = StaticDiGraph(dgu)
+        @test eltype(StaticDiGraph{UInt128, UInt128}(dsgu)) == UInt128
         @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())
@@ -79,8 +81,8 @@ const testdir = dirname(@__FILE__)
         @test @inferred eltype(dhu) == UInt8
         @test dtestfn(ne)
         @test dtestfn(nv)
-        @test dtestfn(in_neighbors, 1)
-        @test dtestfn(out_neighbors, 1)
+        @test dtestfn(inneighbors, 1)
+        @test dtestfn(outneighbors, 1)
         @test dtestfn(vertices)
         @test dtestfn(degree)
         @test dtestfn(degree, 1)
@@ -101,12 +103,12 @@ const testdir = dirname(@__FILE__)
 
     @testset "utils" begin
         A = [1:5;]
-        B = StaticGraphs.fastview(A, 2:3)
+        B = StaticGraphs.view(A, 2:3)
         @test @inferred B == [2,3]
         B[1] = 5
         @test @inferred A == [1,5,3,4,5]
         A = ["a", "b", "c", "d"]
-        @test @inferred StaticGraphs.fastview(A, 2:3) == ["b", "c"]
+        @test @inferred StaticGraphs.view(A, 2:3) == ["b", "c"]
     end # utils
 
     @testset "persistence" begin