update randgraphs.jl to use Channels over Tasks

Fixes deprecation warnings introduced in:

  JuliaLang/julia#19841

Changes an API interface:

  -function Graph(nvg::Int, neg::Int, edgestream::Task)
  +function Graph(nvg::Int, neg::Int, edgestream::Channel)

Iteration over Tasks is deprecated so now we iterate over the Channel.

Author: jpfairbanks

src/generators/randgraphs.jl

@@ -500,8 +500,8 @@ stochastic_block_model(cin::Float64, coff::Float64, n::Vector{Int}; seed::Int =
 Returns a Graph generated according to the Stochastic Block Model (SBM).
 
 `c[a,b]` : Mean number of neighbors of a vertex in block `a` belonging to block `b`.
-Only the upper triangular part is considered, since the lower traingular is
-determined by $c[b,a] = c[a,b] * n[a]/n[b]$.
+           Only the upper triangular part is considered, since the lower traingular is
+           determined by $c[b,a] = c[a,b] * n[a]/n[b]$.
 `n[a]` : Number of vertices in block `a`
 
 The second form samples from a SBM with `c[a,a]=cin`, and `c[a,b]=coff`.
@@ -552,12 +552,12 @@ function stochastic_block_model{T<:Real}(cint::T, cext::T, n::Vector{Int}; seed:
 end
 
 """
-type StochasticBlockModel{T<:Integer,P<:Real}
-n::T
-nodemap::Array{T}
-affinities::Matrix{P}
-rng::MersenneTwister
-end
+    type StochasticBlockModel{T<:Integer,P<:Real}
+        n::T
+        nodemap::Array{T}
+        affinities::Matrix{P}
+        rng::MersenneTwister
+    end
 
 A type capturing the parameters of the SBM.
 Each vertex is assigned to a block and the probability of edge `(i,j)`
@@ -580,7 +580,7 @@ type StochasticBlockModel{T<:Integer,P<:Real}
 end
 
 ==(sbm::StochasticBlockModel, other::StochasticBlockModel) =
-(sbm.n == other.n) && (sbm.nodemap == other.nodemap) && (sbm.affinities == other.affinities)
+    (sbm.n == other.n) && (sbm.nodemap == other.nodemap) && (sbm.affinities == other.affinities)
 
 """A constructor for StochasticBlockModel that uses the sizes of the blocks
 and the affinity matrix. This construction implies that consecutive
@@ -611,17 +611,17 @@ function sbmaffinity(internalp::Vector{Float64}, externalp::Float64, sizes::Vect
 end
 
 function StochasticBlockModel(internalp::Float64,
-    externalp::Float64,
-    size::Int,
-    numblocks::Int;
-    seed::Int = -1)
+                              externalp::Float64,
+                              size::Int,
+                              numblocks::Int;
+                              seed::Int = -1)
     sizes = fill(size, numblocks)
     B = sbmaffinity(fill(internalp, numblocks), externalp, sizes)
     StochasticBlockModel(sizes, B, seed=seed)
 end
 
 function StochasticBlockModel(internalp::Vector{Float64}, externalp::Float64
-    , sizes::Vector{Int}; seed::Int = -1)
+        , sizes::Vector{Int}; seed::Int = -1)
     B = sbmaffinity(internalp, externalp, sizes)
     return StochasticBlockModel(sizes, B, seed=seed)
 end
@@ -634,8 +634,8 @@ between is the affinity between the two parts of each bipartite community
 intra is the probability of an edge within the parts of the partitions.
 
 This is a specific type of SBM with k/2 blocks each with two halves.
-    Each half is connected as a random bipartite graph with probability `intra`
-    The blocks are connected with probability `between`.
+Each half is connected as a random bipartite graph with probability `intra`
+The blocks are connected with probability `between`.
 """
 function nearbipartiteaffinity(sizes::Vector{Int}, between::Float64, intra::Float64)
     numblocks = div(length(sizes), 2)
@@ -656,9 +656,12 @@ end
 
 """Generates a stream of random pairs in 1:n"""
 function random_pair(rng::AbstractRNG, n::Int)
-    while true
-        produce( rand(rng, 1:n), rand(rng, 1:n) )
+    f(ch) = begin
+        while true
+            put!(ch, Edge(rand(rng, 1:n), rand(rng, 1:n)))
+        end
     end
+    return f
 end
 
 
@@ -669,32 +672,36 @@ Take an infinite sample from the sbm.
 Pass to `Graph(nvg, neg, edgestream)` to get a Graph object.
 """
 function make_edgestream(sbm::StochasticBlockModel)
-    pairs = @task random_pair(sbm.rng, sbm.n)
-    for (i,j) in pairs
-        if i == j
-            continue
-        end
-        p = sbm.affinities[sbm.nodemap[i], sbm.nodemap[j]]
-        if rand(sbm.rng) < p
-            produce(i, j)
+    pairs = Channel(random_pair(sbm.rng, sbm.n), ctype=Edge, csize=32)
+    edges(ch) = begin
+        for e in pairs
+            i, j = Tuple(e)
+    	      if i == j
+                continue
+            end
+            p = sbm.affinities[sbm.nodemap[i], sbm.nodemap[j]]
+            if rand(sbm.rng) < p
+                put!(ch, e)
+            end
         end
     end
+    return Channel(edges, ctype=Edge, csize=32)
 end
 
-function Graph(nvg::Int, neg::Int, edgestream::Task)
+function Graph(nvg::Int, neg::Int, edgestream::Channel)
     g = Graph(nvg)
     # println(g)
-    for (i,j) in edgestream
+    for e in edgestream
         # print("$count, $i,$j\n")
-        add_edge!(g, Edge(i, j))
+        add_edge!(g, e)
         ne(g) >= neg && break
     end
     # println(g)
     return g
 end
 
 Graph(nvg::Int, neg::Int, sbm::StochasticBlockModel) =
-Graph(nvg, neg, @task make_edgestream(sbm))
+    Graph(nvg, neg, make_edgestream(sbm))
 
 """counts the number of edges that go between each block"""
 function blockcounts(sbm::StochasticBlockModel, A::AbstractMatrix)

test/generators/randgraphs.jl

@@ -1,4 +1,8 @@
 @testset "Randgraphs" begin
+@test nv(r1) == 10
+@test ne(r1) == 20
+@test nv(r2) == 5
+@test ne(r2) == 10
 
     r1 = Graph(10,20)
     r2 = DiGraph(5,10)
@@ -182,66 +186,67 @@
         @test degree(rr, v) == 8
     end
 
-    rd = random_regular_digraph(10, 8, dir=:out, seed=4)
-    @test nv(rd) == 10
-    @test ne(rd) == 80
-    @test is_directed(rd)
-
-    g = stochastic_block_model(2., 3., [100,100])
-    @test  4.5 < mean(degree(g)) < 5.5
-    g = stochastic_block_model(3., 4., [100,100,100])
-    @test  10.5 < mean(degree(g)) < 11.5
-
-    function generate_nbp_sbm(numedges, sizes)
-        density = 1
-        # print(STDERR, "Generating communites with sizes: $sizes\n")
-        between = density * 0.90
-        intra = density * -0.005
-        noise = density * 0.00501
-        sbm = nearbipartiteSBM(sizes, between, intra, noise)
-        edgestream = @task make_edgestream(sbm)
-        g = Graph(sum(sizes), numedges, edgestream)
-        return sbm, g
-    end
+function generate_nbp_sbm(numedges, sizes)
+    density = 1
+    # print(STDERR, "Generating communites with sizes: $sizes\n")
+    between = density * 0.90
+    intra = density * -0.005
+    noise = density * 0.00501
+    sbm = nearbipartiteSBM(sizes, between, intra, noise)
+    edgestream = make_edgestream(sbm)
+    g = Graph(sum(sizes), numedges, edgestream)
+    return sbm, g
+end
 
 
-    numedges = 100
-    sizes = [10, 10, 10, 10]
-
-    n = sum(sizes)
-    sbm, g = generate_nbp_sbm(numedges, sizes)
-    bc = blockcounts(sbm, g)
-    bp = blockfractions(sbm, g) ./ (sizes * sizes')
-    ratios = bp ./ (sbm.affinities ./ sum(sbm.affinities))
-    @test norm(Array(ratios)) < 0.25
-
-    sizes = [200, 200, 100]
-    internaldeg = 15
-    externaldeg = 6
-    internalp = Float64[internaldeg/i for i in sizes]
-    externalp = externaldeg/sum(sizes)
-    numedges = internaldeg + externaldeg #+ sum(externaldeg.*sizes[2:end])
-    numedges *= div(sum(sizes), 2)
-    sbm = StochasticBlockModel(internalp, externalp, sizes)
-    g = Graph(sum(sizes), numedges, sbm)
-    @test ne(g) <= numedges
-    @test nv(g) == sum(sizes)
-    bc = blockcounts(sbm, g)
-    bp = blockfractions(sbm, g) ./ (sizes * sizes')
-    ratios = bp ./ (sbm.affinities ./ sum(sbm.affinities))
-    @test norm(Array(ratios)) < 0.25
-
-    # check that average degree is not too high
-    # factor of two is cushion for random process
-    @test mean(degree(g)) <= 4//2*numedges/sum(sizes)
-    # check that the internal degrees are higher than the external degrees
-    # 5//4 is cushion for random process.
-    @test all(sum(bc-diagm(diag(bc)), 1) .<= 5//4 .* diag(bc))
-
-
-    sbm2 = StochasticBlockModel(0.5*ones(4), 0.3, 10*ones(Int,4))
-    sbm  = StochasticBlockModel(0.5, 0.3, 10, 4)
-    @test sbm == sbm2
-    sbm.affinities[1,1] = 0
-    @test sbm != sbm2
+function test_sbm(sbm, bp)
+    @test sum(sbm.affinities) != NaN
+    @test all(sbm.affinities .> 0)
+    @test sum(sbm.affinities) != 0
+    @test all(bp .>= 0)
+    @test all(bp .!= NaN)
 end
+
+numedges = 100
+sizes = [10, 10, 10, 10]
+
+n = sum(sizes)
+sbm, g = generate_nbp_sbm(numedges, sizes)
+@test ne(g) >= 0.9numedges
+bc = blockcounts(sbm, g)
+bp = blockfractions(sbm, g) ./ (sizes * sizes')
+ratios = bp ./ (sbm.affinities ./ sum(sbm.affinities))
+test_sbm(sbm, bp)
+@test norm(collect(ratios)) < 0.25
+
+sizes = [200, 200, 100]
+internaldeg = 15
+externaldeg = 6
+internalp = Float64[internaldeg/i for i in sizes]
+externalp = externaldeg/sum(sizes)
+numedges = internaldeg + externaldeg #+ sum(externaldeg.*sizes[2:end])
+numedges *= div(sum(sizes), 2)
+sbm = StochasticBlockModel(internalp, externalp, sizes)
+g = Graph(sum(sizes), numedges, sbm)
+@test ne(g) >= 0.9numedges
+@test ne(g) <= numedges
+@test nv(g) == sum(sizes)
+bc = blockcounts(sbm, g)
+bp = blockfractions(sbm, g) ./ (sizes * sizes')
+test_sbm(sbm, bp)
+ratios = bp ./ (sbm.affinities ./ sum(sbm.affinities))
+@test norm(collect(ratios)) < 0.25
+
+# check that average degree is not too high
+# factor of two is cushion for random process
+@test mean(degree(g)) <= 4//2*numedges/sum(sizes)
+# check that the internal degrees are higher than the external degrees
+# 5//4 is cushion for random process.
+@test all(sum(bc-diagm(diag(bc)), 1) .<= 5//4 .* diag(bc))
+
+
+sbm2 = StochasticBlockModel(0.5*ones(4), 0.3, 10*ones(Int,4))
+sbm  = StochasticBlockModel(0.5, 0.3, 10, 4)
+@test sbm == sbm2
+sbm.affinities[1,1] = 0
+@test sbm != sbm2