Merge branch 'master' into sbromberger/adjmx

Author: sbromberger

.travis.yml

@@ -6,17 +6,16 @@ os:
 julia:
   - 1.0
   - nightly
+
+matrix:
+  allow_failures:
+    - julia: nightly
+
 notifications:
   email: false
 git:
   depth: 99999999
 
-## uncomment the following lines to allow failures on nightly julia
-## (tests will run but not make your overall status red)
-#matrix:
-#  allow_failures:
-#  - julia: nightly
-
 ## uncomment and modify the following lines to manually install system packages
 #addons:
 #  apt: # apt-get for linux

src/StaticGraphs.jl

@@ -73,7 +73,7 @@ end
 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)
+vertices(g::AbstractStaticGraph{T, U}) where T where U = Base.OneTo(nv(g))
 
 has_edge(g::AbstractStaticGraph, e::AbstractStaticEdge) =
     insorted(dst(e), outneighbors(g, src(e)))

src/overrides.jl

@@ -11,4 +11,3 @@ function adjacency_matrix(g::StaticDiGraph{I,U}, T::DataType; dir = :out) where
     dir != :out && @warn("direction `$dir` not defined for adjacency matrices on StaticGraphs; defaulting to `out`")
     return z
 end
-

src/staticdigraph.jl

@@ -24,12 +24,12 @@ end
 ne(g::StaticDiGraph{T, U}) where T where U = U(length(g.f_vec))
 
 # sorted src, dst vectors for forward and backward edgelists.
-function StaticDiGraph(n_v, f_ss::AbstractVector, f_ds::AbstractVector, b_ss::AbstractVector, b_ds::AbstractVector)
+function StaticDiGraph(nvtx::I, f_ss::AbstractVector{F}, f_ds::AbstractVector{D}, b_ss::AbstractVector{B}, b_ds::AbstractVector{S}) where {I<:Integer,S<:Integer,D<:Integer,B<:Integer,F<:Integer}
     length(f_ss) == length(f_ds) == length(b_ss) == length(b_ds) || error("source and destination vectors must be equal length")
-    (n_v == 0 || length(f_ss) == 0) && return StaticDiGraph(UInt8[], UInt8[1], UInt8[], UInt8[1])
-    f_ind = [searchsortedfirst(f_ss, x) for x in 1:n_v]
+    (nvtx == 0 || length(f_ss) == 0) && return StaticDiGraph(UInt8[], UInt8[1], UInt8[], UInt8[1])
+    f_ind = [searchsortedfirst(f_ss, x) for x in Base.OneTo(nvtx)]
     push!(f_ind, length(f_ss)+1)
-    b_ind = [searchsortedfirst(b_ss, x) for x in 1:n_v]
+    b_ind = [searchsortedfirst(b_ss, x) for x in Base.OneTo(nvtx)]
     push!(b_ind, length(b_ss)+1)
     T = mintype(maximum(f_ds))
     U = mintype(f_ind[end])
@@ -42,21 +42,25 @@ function StaticDiGraph(n_v, f_ss::AbstractVector, f_ds::AbstractVector, b_ss::Ab
 end
 
 # sorted src, dst tuples for forward and backward
-function StaticDiGraph(n_v, f_sd::Vector{Tuple{T, T}}, b_sd::Vector{Tuple{T, T}}) where T <: Integer
+function StaticDiGraph(nvtx::I, f_sd::Vector{Tuple{T, T}}, b_sd::Vector{Tuple{T, T}}) where {T<:Integer,I<:Integer}
     f_ss = [x[1] for x in f_sd]
     f_ds = [x[2] for x in f_sd]
     b_ss = [x[1] for x in b_sd]
     b_ds = [x[2] for x in b_sd]
 
-    StaticDiGraph(n_v, f_ss, f_ds, b_ss, b_ds)
+    return StaticDiGraph(nvtx, f_ss, f_ds, b_ss, b_ds)
 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)])
 
-    StaticDiGraph(nv(g), f_sd, b_sd)
+    return StaticDiGraph(nv(g), f_sd, b_sd)
+end
+
+function StaticDiGraph()
+    return StaticDiGraph(UInt8[], UInt8[1], UInt8[], UInt8[1])
 end
 
 function StaticDiGraph{T, U}(s::StaticDiGraph) where T <: Integer where U <: Integer
@@ -68,7 +72,6 @@ function StaticDiGraph{T, U}(s::StaticDiGraph) where T <: Integer where U <: Int
 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)
@@ -85,6 +88,7 @@ outdegree(g::StaticDiGraph) = [outdegree(g, v) for v in vertices(g)]
 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

@@ -10,13 +10,12 @@ struct StaticGraph{T<:Integer, U<:Integer} <: AbstractStaticGraph{T, U}
     f_ind::Vector{U}
 end
 
-
 # sorted src, dst vectors
-# note: this requires reverse edges included in the sorted vector.  
-function StaticGraph(n_v, ss::AbstractVector, ds::AbstractVector)
+# note: this requires reverse edges included in the sorted vector.
+function StaticGraph(nvtx::I, ss::AbstractVector{S}, ds::AbstractVector{D}) where {I<:Integer,S<:Integer,D<:Integer}
     length(ss) != length(ds) && error("source and destination vectors must be equal length")
-    (n_v == 0 || length(ss) == 0) && return StaticGraph(UInt8[], UInt8[1])
-    f_ind = [searchsortedfirst(ss, x) for x in 1:n_v]
+    (nvtx == 0 || length(ss) == 0) && return StaticGraph()
+    f_ind = [searchsortedfirst(ss, x) for x in Base.OneTo(nvtx)]
     push!(f_ind, length(ss)+1)
     T = mintype(maximum(ds))
     U = mintype(f_ind[end])
@@ -30,33 +29,37 @@ function StaticGraph{T, U}(s::StaticGraph) where T <: Integer where U <: Integer
 end
 
 # sorted src, dst tuples
-function StaticGraph(n_v, sd::Vector{Tuple{T, T}}) where T <: Integer
+function StaticGraph(nvtx::I, sd::Vector{Tuple{T, T}}) where {T<:Integer, I<:Integer}
     ss = [x[1] for x in sd]
     ds = [x[2] for x in sd]
-    StaticGraph(n_v, ss, ds)
+    return StaticGraph(nvtx, ss, ds)
 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))
-    StaticGraph(nv(g), sd)
+    return StaticGraph(nv(g), sd)
+end
+
+function StaticGraph()
+    return StaticGraph(UInt8[], UInt8[1])
 end
 
 badj(g::StaticGraph, s) = fadj(g, s)
 
 ne(g::StaticGraph{T, U}) where T where U = U(length(g.f_vec) ÷ 2)
 
-function has_edge(g::StaticGraph, e::StaticGraphEdge)
+function has_edge(e::StaticGraphEdge, g::StaticGraph)
     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)))

src/utils.jl

@@ -1,3 +1,31 @@
+struct UnsafeVectorView{T,U} <: AbstractVector{T}
+    offset::U
+    len::U
+    ptr::Ptr{T}
+end
+
+@inline UnsafeVectorView(parent::Union{Vector, Base.FastContiguousSubArray}, range::UnitRange) = UnsafeVectorView(start(range) - 1, length(range), pointer(parent))
+@inline Base.size(v::UnsafeVectorView) = (v.len,)
+@inline Base.getindex(v::UnsafeVectorView, idx) = unsafe_load(v.ptr, idx + v.offset)
+@inline Base.setindex!(v::UnsafeVectorView, value, idx) = unsafe_store!(v.ptr, value, idx + v.offset)
+@inline Base.length(v::UnsafeVectorView) = v.len
+Base.IndexStyle(::Type{V}) where {V <: UnsafeVectorView} = IndexLinear()
+
+"""
+UnsafeVectorView only works for isbits types. For other types, we're already
+allocating lots of memory elsewhere, so creating a new SubArray is fine.
+This function looks type-unstable, but the isbits(T) test can be evaluated
+by the compiler, so the result is actually type-stable.
+From https://github.com/rdeits/NNLS.jl/blob/0a9bf56774595b5735bc738723bd3cb94138c5bd/src/NNLS.jl#L218.
+"""
+@inline function fastview(parent::Union{Vector{T}, Base.FastContiguousSubArray{T}}, range::UnitRange) where T
+    if isbits(T)
+        UnsafeVectorView(parent, range)
+    else
+        view(parent, range)
+    end
+end
+
 """
     mintype(v)
 
@@ -11,4 +39,3 @@ function mintype(v::T) where T <: Integer
     return T
 end
 
-    

test/runtests.jl

@@ -17,6 +17,8 @@ const testdir = dirname(@__FILE__)
         gu = squash(g)
         sg = StaticGraph(g)
         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"
@@ -55,6 +57,14 @@ const testdir = dirname(@__FILE__)
         @test z[1,2]
         @test !z[1,4]
         @test z == adjacency_matrix(hu, Bool, dir=:in) == adjacency_matrix(hu, Bool, dir=:both)
+
+        # empty constructors
+        @test nv(gempty) === 0x00
+        @test typeof(LightGraphs.nv(gempty)) == UInt8
+        @test length(LightGraphs.edges(gempty)) === 0x00
+        @test nv(gdempty) === 0x00
+        @test length(LightGraphs.edges(gdempty)) === 0x00
+
     end # staticgraph
 
     @testset "staticdigraph" begin