rename v_vertices and f_vertices to eachvariable and eachfactor

Author: stecrotti

src/IndexedFactorGraphs.jl

@@ -19,7 +19,7 @@ include("factorgraph.jl")
 include("generators.jl")
 include("infinite_regular_factorgraph.jl")
 
-export AbstractFactorGraph, FactorGraph, nvariables, nfactors, v_vertices, f_vertices, f_vertex, v_vertex,
+export AbstractFactorGraph, FactorGraph, nvariables, nfactors, eachvariable, eachfactor, f_vertex, v_vertex,
     pairwise_interaction_graph,
     neighbors, edges, src, dst, idx, ne, nv, degree,
     edge_indices, inedges, outedges,

src/factorgraph.jl

@@ -88,18 +88,18 @@ IndexedGraphs.nv(g::FactorGraph) = nv(g.g)
 IndexedGraphs.ne(g::FactorGraph) = ne(g.g)
 
 """
-    v_vertices(g::FactorGraph)
+    eachvariable(g::FactorGraph)
 
 Return a lazy iterator to the indices of variable vertices in `g`.
 """
-v_vertices(g::FactorGraph) = 1:nvariables(g)
+eachvariable(g::FactorGraph) = 1:nvariables(g)
 
 """
-    f_vertices(g::FactorGraph)
+    eachfactor(g::FactorGraph)
 
 Return a lazy iterator to the indices of factor vertices in `g`.
 """
-f_vertices(g::FactorGraph) = 1:nfactors(g)
+eachfactor(g::FactorGraph) = 1:nfactors(g)
 
 """
     IndexedGraphs.neighbors(g::FactorGraph, v::FactorGraphVertex)

src/infinite_regular_factorgraph.jl

@@ -27,8 +27,8 @@ nvariables(::InfiniteRegularFactorGraph) = 1
 nfactors(::InfiniteRegularFactorGraph) = 1
 Graphs.ne(::InfiniteRegularFactorGraph) = 1
 Graphs.edges(::InfiniteRegularFactorGraph) = (IndexedEdge(1,1,1) for _ in 1:1)
-v_vertices(::InfiniteRegularFactorGraph) = 1:1
-f_vertices(::InfiniteRegularFactorGraph) = 1:1
+eachvariable(::InfiniteRegularFactorGraph) = 1:1
+eachfactor(::InfiniteRegularFactorGraph) = 1:1
 
 IndexedGraphs.degree(g::InfiniteRegularFactorGraph, v::FactorGraphVertex) = length(neighbors(g, v))
 

test/factorgraph.jl

@@ -7,15 +7,15 @@ g = FactorGraph(A)
 @testset "Basics" begin
     @test @inferred nfactors(g) == m
     @test @inferred nvariables(g) == n
-    @test all(@inferred degree(g, f_vertex(a)) == length(@inferred neighbors(g,f_vertex(a))) for a in f_vertices(g))
-    @test all(@inferred degree(g, v_vertex(i)) == length(@inferred neighbors(g,v_vertex(i))) for i in v_vertices(g))
+    @test all(@inferred degree(g, f_vertex(a)) == length(@inferred neighbors(g,f_vertex(a))) for a in eachfactor(g))
+    @test all(@inferred degree(g, v_vertex(i)) == length(@inferred neighbors(g,v_vertex(i))) for i in eachvariable(g))
 
     @test length(collect(@inferred edges(g))) == @inferred ne(g)
 
-    @test all(all(src(e)==a for (e,a) in zip(inedges(g, v_vertex(i)), neighbors(g, v_vertex(i)))) for i in v_vertices(g))
-    @test all(all(src(e)==i for (e,i) in zip(inedges(g, f_vertex(a)), neighbors(g, f_vertex(a)))) for a in f_vertices(g))
-    @test all(all(dst(e)==a for (e,a) in zip(outedges(g, v_vertex(i)), neighbors(g, v_vertex(i)))) for i in v_vertices(g))
-    @test all(all(dst(e)==i for (e,i) in zip(outedges(g, f_vertex(a)), neighbors(g, f_vertex(a)))) for a in f_vertices(g))
+    @test all(all(src(e)==a for (e,a) in zip(inedges(g, v_vertex(i)), neighbors(g, v_vertex(i)))) for i in eachvariable(g))
+    @test all(all(src(e)==i for (e,i) in zip(inedges(g, f_vertex(a)), neighbors(g, f_vertex(a)))) for a in eachfactor(g))
+    @test all(all(dst(e)==a for (e,a) in zip(outedges(g, v_vertex(i)), neighbors(g, v_vertex(i)))) for i in eachvariable(g))
+    @test all(all(dst(e)==i for (e,i) in zip(outedges(g, f_vertex(a)), neighbors(g, f_vertex(a)))) for a in eachfactor(g))
 
     @test_throws ArgumentError degree(g, 1)
     @test_throws ArgumentError neighbors(g, 1)
@@ -51,10 +51,10 @@ end
 end
 
 @testset "Edge indices" begin
-    @test all(v_vertices(g)) do i
+    @test all(eachvariable(g)) do i
         idx.(collect(inedges(g, v_vertex(i)))) == edge_indices(g, v_vertex(i))
     end
-    @test all(f_vertices(g)) do a
+    @test all(eachfactor(g)) do a
         idx.(collect(inedges(g, f_vertex(a)))) == edge_indices(g, f_vertex(a))
     end
 end

test/infinite_regular_factorgraph.jl

@@ -8,8 +8,8 @@ g = InfiniteRegularFactorGraph(kᵢ, kₐ)
     @test nfactors(g) == 1
     @test nvariables(g) == 1
     @test ne(g) == 1
-    @test v_vertices(g) == 1:1
-    @test f_vertices(g) == 1:1
+    @test eachvariable(g) == 1:1
+    @test eachfactor(g) == 1:1
     @test all(edges(g)) do (i, j, id)
         i == 1 && j == 1 && id == 1
     end
@@ -20,10 +20,10 @@ end
 end 
 
 @testset "Edge indices" begin
-    @test all(v_vertices(g)) do i
+    @test all(eachvariable(g)) do i
         idx.(collect(inedges(g, v_vertex(i)))) == edge_indices(g, v_vertex(i))
     end
-    @test all(f_vertices(g)) do a
+    @test all(eachfactor(g)) do a
         idx.(collect(outedges(g, f_vertex(a)))) == edge_indices(g, f_vertex(a))
     end
 end

test/runtests.jl

@@ -17,8 +17,8 @@ Check type inference for functions that are likely to be called in hot loops
 """
 function test_type_inference(g::AbstractFactorGraph)
     all_edges = @inferred edge_indices(g)
-    i = rand(rng, @inferred v_vertices(g))
-    a = rand(rng, @inferred f_vertices(g))
+    i = rand(rng, @inferred eachvariable(g))
+    a = rand(rng, @inferred eachfactor(g))
     di = @inferred degree(g, @inferred v_vertex(i))
     da = @inferred degree(g, @inferred f_vertex(a))
     ∂i = @inferred neighbors(g, v_vertex(i))