fixes most depwarns as of 20180529

CONTRIBUTING.md

@@ -60,17 +60,17 @@ Locate the section for your github remote in the `.git/config` file. It looks li
 
 ```
 [remote "origin"]
-	fetch = +refs/heads/*:refs/remotes/origin/*
-	url = git@github.com:JuliaGraphs/LightGraphs.jl.git
+    fetch = +refs/heads/*:refs/remotes/origin/*
+    url = git@github.com:JuliaGraphs/LightGraphs.jl.git
 ```
 
 Now add the line `fetch = +refs/pull/*/head:refs/remotes/origin/pr/*` to this section. Obviously, change the github url to match your project's URL. It ends up looking like this:
 
 ```
 [remote "origin"]
-	fetch = +refs/heads/*:refs/remotes/origin/*
-	url = git@github.com:JuliaGraphs/LightGraphs.jl.git
-	fetch = +refs/pull/*/head:refs/remotes/origin/pr/*
+    fetch = +refs/heads/*:refs/remotes/origin/*
+    url = git@github.com:JuliaGraphs/LightGraphs.jl.git
+    fetch = +refs/pull/*/head:refs/remotes/origin/pr/*
 ```
 
 Now fetch all the pull requests:

benchmark/core.jl

@@ -7,7 +7,7 @@ function bench_iteredges(g::AbstractGraph)
 end
 
 function bench_has_edge(g::AbstractGraph)
-    srand(1)
+    Random.srand(1)
     nvg = nv(g)
     srcs = rand([1:nvg;], cld(nvg, 4))
     dsts = rand([1:nvg;], cld(nvg, 4))

docs/src/distance.md

@@ -11,8 +11,8 @@ Pages   = ["distance.md"]
 ```@autodocs
 Modules = [LightGraphs]
 Pages   = [
-	"distance.jl",
-	"transitivity.jl"
+    "distance.jl",
+    "transitivity.jl"
 ]
 Private = false
 ```

src/LightGraphs.jl

@@ -1,25 +1,24 @@
 __precompile__(true)
 module LightGraphs
 
+using SimpleTraits
+
 import CodecZlib
 import DataStructures
+import DelimitedFiles
+import Distributed
+import IterativeEigensolvers
+import LinearAlgebra
+import Markdown
+import Random
+import SharedArrays
+import SparseArrays
 
-using SimpleTraits
-using SharedArrays
-using SparseArrays
-using LinearAlgebra
-using IterativeEigensolvers
-using SharedArrays
-using Markdown
-using DelimitedFiles
 import Base: write, ==, <, *, ≈, convert, isless, issubset, union, intersect,
             reverse, reverse!, isassigned, getindex, setindex!, show,
             print, copy, in, sum, size, eltype, length, ndims, transpose,
             ctranspose, join, start, next, done, eltype, get, Pair, Tuple, zero
-import Random: GLOBAL_RNG
-import Distributed: @distributed, @sync
-import SparseArrays: sparse, blockdiag
-import LinearAlgebra: issymmetric, mul!
+
 
 export
 # Interface

src/SimpleGraphs/simpledigraph.jl

@@ -31,7 +31,7 @@ SimpleDiGraph(n::T) where T<:Integer = SimpleDiGraph{T}(n)
 SimpleDiGraph(::Type{T}) where T<:Integer = SimpleDiGraph{T}(zero(T))
 
 # sparse adjacency matrix constructor: SimpleDiGraph(adjmx)
-function SimpleDiGraph{T}(adjmx::SparseMatrixCSC{U}) where T<:Integer where U<:Real
+function SimpleDiGraph{T}(adjmx::SparseArrays.SparseMatrixCSC{U}) where T<:Integer where U<:Real
     dima, dimb = size(adjmx)
     isequal(dima, dimb) || throw(ArgumentError("Adjacency / distance matrices must be square"))
 

src/SimpleGraphs/simplegraph.jl

@@ -5,15 +5,15 @@ const SimpleGraphEdge = SimpleEdge
 
 A type representing an undirected graph.
 """
-mutable struct SimpleGraph{T<:Integer} <: AbstractSimpleGraph{T}
+mutable struct SimpleGraph{T <: Integer} <: AbstractSimpleGraph{T}
     ne::Int
     fadjlist::Vector{Vector{T}} # [src]: (dst, dst, dst)
 end
 
 eltype(x::SimpleGraph{T}) where T = T
 
 # Graph{UInt8}(6), Graph{Int16}(7), Graph{UInt8}()
-function SimpleGraph{T}(n::Integer = 0) where T<:Integer
+function SimpleGraph{T}(n::Integer=0) where T <: Integer
     fadjlist = [Vector{T}() for _ = one(T):n]
     return SimpleGraph{T}(0, fadjlist)
 end
@@ -22,26 +22,26 @@ end
 SimpleGraph() = SimpleGraph{Int}()
 
 # SimpleGraph(6), SimpleGraph(0x5)
-SimpleGraph(n::T) where T<:Integer = SimpleGraph{T}(n)
+SimpleGraph(n::T) where T <: Integer = SimpleGraph{T}(n)
 
 # SimpleGraph(UInt8)
-SimpleGraph(::Type{T}) where T<:Integer = SimpleGraph{T}(zero(T))
+SimpleGraph(::Type{T}) where T <: Integer = SimpleGraph{T}(zero(T))
 
 # Graph{UInt8}(adjmx)
-function SimpleGraph{T}(adjmx::AbstractMatrix) where T<:Integer
+function SimpleGraph{T}(adjmx::AbstractMatrix) where T <: Integer
     dima, dimb = size(adjmx)
     isequal(dima, dimb) || throw(ArgumentError("Adjacency / distance matrices must be square"))
-    issymmetric(adjmx) || throw(ArgumentError("Adjacency / distance matrices must be symmetric"))
+    LinearAlgebra.issymmetric(adjmx) || throw(ArgumentError("Adjacency / distance matrices must be symmetric"))
 
     g = SimpleGraph(T(dima))
-    @inbounds for i in findall(triu(adjmx).!=0)
+    @inbounds for i in findall(triu(adjmx) .!= 0)
         add_edge!(g, i[1], i[2])
     end
     return g
 end
 
 # converts Graph{Int} to Graph{Int32}
-function SimpleGraph{T}(g::SimpleGraph) where T<:Integer
+function SimpleGraph{T}(g::SimpleGraph) where T <: Integer
     h_fadj = [Vector{T}(x) for x in fadj(g)]
     return SimpleGraph(ne(g), h_fadj)
 end
@@ -71,7 +71,7 @@ function SimpleGraph(g::SimpleDiGraph)
     return SimpleGraph(edgect ÷ 2, newfadj)
 end
 
-@inbounds function cleanupedges!(fadjlist::Vector{Vector{T}}) where T<:Integer
+@inbounds function cleanupedges!(fadjlist::Vector{Vector{T}}) where T <: Integer
     neg = 0
     for v in 1:length(fadjlist)
         if !issorted(fadjlist[v])
@@ -90,7 +90,7 @@ end
     return neg ÷ 2
 end
 
-function SimpleGraph(edge_list::Vector{SimpleGraphEdge{T}}) where T<:Integer
+function SimpleGraph(edge_list::Vector{SimpleGraphEdge{T}}) where T <: Integer
     nvg = zero(T)
     @inbounds(
     for e in edge_list
@@ -136,10 +136,10 @@ function SimpleGraph(edge_list::Vector{SimpleGraphEdge{T}}) where T<:Integer
 end
 
 
-@inbounds function add_to_fadjlist!(fadjlist::Vector{Vector{T}}, s::T, d::T) where T<:Integer
+@inbounds function add_to_fadjlist!(fadjlist::Vector{Vector{T}}, s::T, d::T) where T <: Integer
     nvg = length(fadjlist)
     nvg_new = max(nvg, s, d)
-    for v = (nvg+1):nvg_new
+    for v = (nvg + 1):nvg_new
         push!(fadjlist, Vector{T}())
     end
 
@@ -174,7 +174,7 @@ function _SimpleGraphFromIterator(iter)::SimpleGraph
     return g
 end
 
-function _SimpleGraphFromIterator(iter, ::Type{SimpleGraphEdge{T}}) where T<:Integer
+function _SimpleGraphFromIterator(iter, ::Type{SimpleGraphEdge{T}}) where T <: Integer
     fadjlist = Vector{Vector{T}}() 
     @inbounds(
     for e in iter
@@ -209,7 +209,7 @@ function SimpleGraphFromIterator(iter)::SimpleGraph
 end
 
 
-edgetype(::SimpleGraph{T}) where T<:Integer = SimpleGraphEdge{T}
+edgetype(::SimpleGraph{T}) where T <: Integer = SimpleGraphEdge{T}
 
 """
     badj(g::SimpleGraph[, v::Integer])

src/centrality/betweenness.jl

@@ -75,7 +75,7 @@ function parallel_betweenness_centrality(
 
     # Parallel reduction
 
-    betweenness = @distributed (+) for s in vs
+    betweenness = Distributed.@distributed (+) for s in vs
         temp_betweenness = zeros(n_v)
         if degree(g, s) > 0  # this might be 1?
             state = dijkstra_shortest_paths(g, s, distmx; allpaths=true, trackvertices=true)

src/centrality/closeness.jl

@@ -9,9 +9,8 @@ of the graph `g`. Return a vector representing the centrality calculated for eac
 node `n` by ``\\frac{|δ_n|}{|V|-1}``, where ``δ_n`` is the set of vertices reachable
 from node `n`.
 """
-function closeness_centrality(
-    g::AbstractGraph,
-    distmx::AbstractMatrix = weights(g);
+function closeness_centrality(g::AbstractGraph,
+    distmx::AbstractMatrix=weights(g);
     normalize=true)
 
     n_v = nv(g)
@@ -37,16 +36,15 @@ function closeness_centrality(
     return closeness
 end
 
-function parallel_closeness_centrality(
-    g::AbstractGraph,
-    distmx::AbstractMatrix = weights(g);
+function parallel_closeness_centrality(g::AbstractGraph,
+    distmx::AbstractMatrix=weights(g);
     normalize=true)::Vector{Float64}
 
     n_v = Int(nv(g))
 
-    closeness = SharedVector{Float64}(n_v)
+    closeness = SharedArrays.SharedVector{Float64}(n_v)
 
-    @sync @distributed for u in vertices(g)
+    Distributed.@sync Distributed.@distributed for u in vertices(g)
         if degree(g, u) == 0     # no need to do Dijkstra here
             closeness[u] = 0.0
         else
@@ -63,5 +61,5 @@ function parallel_closeness_centrality(
             end
         end
     end
-    return sdata(closeness)
+    return SharedArrays.sdata(closeness)
 end

src/centrality/eigenvector.jl

@@ -24,4 +24,4 @@ eigenvector of the adjacency matrix \$\\mathbf{A}\$.
 - Mark E. J. Newman: Networks: An Introduction.
        Oxford University Press, USA, 2010, pp. 169.
 """
-eigenvector_centrality(g::AbstractGraph) = abs.(vec(eigs(adjacency_matrix(g), nev=1)[2]))::Vector{Float64}
+eigenvector_centrality(g::AbstractGraph) = abs.(vec(IterativeEigensolvers.eigs(adjacency_matrix(g), nev=1)[2]))::Vector{Float64}

src/centrality/katz.jl

@@ -30,9 +30,9 @@ the centrality calculated for each node in `g`.
 function katz_centrality(g::AbstractGraph, α::Real=0.3)
     nvg = nv(g)
     v = ones(Float64, nvg)
-    spI = sparse(one(Float64) * I, nvg, nvg)
+    spI = SparseArrays.sparse(one(Float64) * LinearAlgebra.I, nvg, nvg)
     A = adjacency_matrix(g, Bool; dir=:in)
     v = (spI - α * A) \ v
-    v /=  norm(v)
+    v /=  LinearAlgebra.norm(v)
     return v
 end

src/centrality/radiality.jl

@@ -28,23 +28,23 @@ function radiality_centrality(g::AbstractGraph)::Vector{Float64}
         dmtr = max(dmtr, maximum(d.dists))
         meandists[v] = sum(d.dists) / (n_v - 1) # ignore the source vx
     end
-    meandists = (dmtr + 1).-(meandists)
-    return meandists./dmtr
+    meandists = (dmtr + 1) .- (meandists)
+    return meandists ./ dmtr
 end
 
 function parallel_radiality_centrality(g::AbstractGraph)::Vector{Float64}
     n_v = nv(g)
     vs = vertices(g)
     n = ne(g)
-    meandists = SharedVector{Float64}(Int(n_v))
-    maxdists = SharedVector{Float64}(Int(n_v))
+    meandists = SharedArrays.SharedVector{Float64}(Int(n_v))
+    maxdists = SharedArrays.SharedVector{Float64}(Int(n_v))
 
-    @sync @distributed for i = 1:n_v
+    Distributed.@sync Distributed.@distributed for i = 1:n_v
         d = dijkstra_shortest_paths(g, vs[i])
         maxdists[i] = maximum(d.dists)
         meandists[i] = sum(d.dists) / (n_v - 1)
     end
     dmtr = maximum(maxdists)
     radialities = collect(meandists)
-    return ((dmtr + 1).-radialities)./dmtr
+    return ((dmtr + 1) .- radialities) ./ dmtr
 end

src/centrality/stress.jl

@@ -43,7 +43,7 @@ function parallel_stress_centrality(
 
     # Parallel reduction
 
-    stress = @distributed (+) for s in vs
+    stress = Distributed.@distributed (+) for s in vs
         temp_stress = zeros(Int, n_v)
         if degree(g, s) > 0  # this might be 1?
             state = dijkstra_shortest_paths(g, s; allpaths=true, trackvertices=true)