rgraphum 0.0.1.alpha

data/test/lib/rgraphum/edge_test.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumEdgeTest < MiniTest::Test
+  def setup
+    @graph = Rgraphum::Graph.new
+    @graph.vertices << { id: 1, label: "hoge" }
+    @graph.vertices << { id: 2, label: "huga" }
+
+    @vertex0, @vertex1 = @graph.vertices
+
+    @vertex0.edges << { source: @vertex0, target: @vertex1 }
+
+    @edge0 = @graph.edges[0]
+  end
+
+  def test_find_vertices_for_source_and_target
+    source_vertex = @edge0.find_vertex(:source, @graph.vertices)
+    p source_vertex if Rgraphum.verbose?
+  end
+
+  def test_vertex_within_term
+    t = Time.now
+    vertex_a = Rgraphum::Vertex.new
+    vertex_a.start = t
+    vertex_a.end   = t + 2
+
+    vertex_b = Rgraphum::Vertex.new
+    vertex_b.start = t + 1
+    vertex_b.end   = t + 3
+
+    assert_equal true,  vertex_a.within_term(vertex_b)
+    assert_equal false, vertex_b.within_term(vertex_a)
+  end
+
+  def test_edge_dump_and_load
+    vertex1 = Rgraphum::Vertex.new(id: 1, label: "vertex 1")
+    vertex2 = Rgraphum::Vertex.new(id: 2, label: "vertex 2")
+    edge  = Rgraphum::Edge.new({source: vertex1, target: vertex2})
+
+    data = Marshal.dump(edge)
+    edge_dash = Marshal.load(data)
+
+    rg_assert_equal edge, edge_dash
+    rg_assert_equal edge.source, edge_dash.source
+    rg_assert_equal edge.target, edge_dash.target
+  end
+
+  def test_invalid_field
+    v1 = Rgraphum::Vertex.new(label: "1")
+    v2 = Rgraphum::Vertex.new(label: "2")
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(source: v1, target: v2, labeeeeeeeeeeeeeeeeeeeel: "label")
+    end
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(source: v1, target: v2, label: "label", labeeeeeeeeeeeeeeeeeeeel: "label")
+    end
+  end
+
+  def test_invalid_source
+    v1 = Rgraphum::Vertex.new(label: "1")
+    v2 = Rgraphum::Vertex.new(label: "2")
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(target: v2, label: "label")
+    end
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(source: nil, target: v2, label: "label")
+    end
+  end
+
+  def test_invalid_target
+    v1 = Rgraphum::Vertex.new(label: "1")
+    v2 = Rgraphum::Vertex.new(label: "2")
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(source: v1, label: "label")
+    end
+
+    assert_raises(ArgumentError) do
+      Rgraphum::Edge.new(source: v1, target: nil, label: "label")
+    end
+  end
+end

data/test/lib/rgraphum/edges_test.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumEdgesTest < MiniTest::Test
+  def setup
+    @graph = Rgraphum::Graph.new
+    @graph.vertices << { id: 1, label: "hoge" }
+    @graph.vertices << { id: 2, label: "huga" }
+
+    @vertex0, @vertex1 = @graph.vertices
+    @vertex0.edges << { source: @vertex0, target: @vertex1 }
+
+    @edge0 = @graph.edges[0]
+  end
+
+  def test_edges
+    assert_instance_of Rgraphum::Vertex, @vertex0
+    assert_instance_of Rgraphum::Edges,  @vertex0.edges
+
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @vertex0.edges
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @vertex1.edges
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @graph.edges
+
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @vertex0.edges
+    assert_equal 1, @vertex0.edges.size
+    assert_equal 0, @vertex0.edges[0].id
+    rg_assert_equal @vertex0, @vertex0.edges[0].source
+    rg_assert_equal @vertex1, @vertex0.edges[0].target
+
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @vertex1.edges
+    assert_equal 1, @vertex1.edges.size
+    assert_equal 0, @vertex1.edges[0].id
+    rg_assert_equal @vertex0, @vertex1.edges[0].source
+    rg_assert_equal @vertex1, @vertex1.edges[0].target
+
+    # rg_assert_equal [ { id: 0, :source => @vertex0, target: @vertex1 } ], @graph.edges
+    assert_equal 1, @graph.edges.size
+    assert_equal 0, @graph.edges[0].id
+    rg_assert_equal @vertex0, @graph.edges[0].source
+    rg_assert_equal @vertex1, @graph.edges[0].target
+  end
+
+  def test_edges_dump_and_load
+    vertex1 = Rgraphum::Vertex.new(id: 1, label: "vertex 1")
+    vertex2 = Rgraphum::Vertex.new(id: 2, label: "vertex 2")
+    vertex3 = Rgraphum::Vertex.new(id: 3, label: "vertex 3")
+    edge1 = Rgraphum::Edge.new(source: vertex1, target: vertex2)
+    edge2 = Rgraphum::Edge.new(source: vertex2, target: vertex3)
+    edges = [edge1, edge2, edge1]
+
+    data = Marshal.dump(edges)
+    edges_dash = Marshal.load(data)
+
+    rg_assert_equal edges, edges_dash
+    rg_refute_equal edges_dash[0], edges_dash[1]
+    assert_same  edges_dash[0], edges_dash[2]
+  end
+
+  def test_delete
+    @graph.edges << { source: @vertex1, target: @vertex0 }
+    @edge1 = @graph.edges[-1]
+    # v0 -> v1
+    #    <-
+    assert_equal 2, @graph.vertices.size
+    assert_equal 2, @graph.edges.size
+
+    @graph.edges.delete @edge0
+
+    # v0    v1
+    #    <-
+    assert_equal 2, @graph.vertices.size
+    assert_equal 1, @graph.edges.size
+    assert_equal 1, @vertex0.edges.size
+    assert_equal 1, @vertex1.edges.size
+    rg_assert_equal @edge1,@vertex0.edges[0]
+    rg_assert_equal @edge1,@vertex1.edges[0]
+    rg_assert_equal @edge1.source, @vertex1
+    rg_assert_equal @edge1.target, @vertex0
+  end
+
+  # delete_if calls delete
+  # delete_if == reject!
+  def test_delete_if
+    graph = Rgraphum::Graph.new
+    (0..9).each do |i|
+      graph.vertices << { label: "v#{i}" }
+    end
+    (0..9).each do |i|
+      graph.edges << {
+        source: graph.vertices[i],
+        target: graph.vertices[(i+1) % 10],
+        weight: i,
+      }
+    end
+
+    # v0 -> v1 -> v2 -> v3 -> v4 -> v5 -> v6 -> v7 -> v8 -> v9
+    #  ^                                                     |
+    #  +-----------------------------------------------------+
+    assert_equal 10, graph.vertices.size
+    assert_equal 10, graph.edges.size
+    graph.vertices do |vertex|
+      assert_equal 2, vertex.edges.size
+    end
+
+    graph.edges.delete_if { |edge| edge.weight.odd? }
+    # graph.edges.reject! { |edge| edge.weight.odd? }
+
+    # v0 -> v1    v2 -> v3    v4 -> v5    v6 -> v7    v8 -> v9
+    assert_equal 10, graph.vertices.size
+    assert_equal  5, graph.edges.size, "edges.size was 10 but deleted 5 edges"
+
+    assert_equal  0, graph.edges[0].weight
+    assert_equal  2, graph.edges[1].weight
+    assert_equal  4, graph.edges[2].weight
+    assert_equal  6, graph.edges[3].weight
+    assert_equal  8, graph.edges[4].weight
+
+    graph.vertices do |vertex|
+      assert_equal 1, vertex.edges.size
+    end
+  end
+
+  def test_reject
+    graph = Rgraphum::Graph.new
+    (0..9).each do |i|
+      graph.vertices << { label: "v#{i}" }
+    end
+    (0..9).each do |i|
+      graph.edges << {
+        source: graph.vertices[i],
+        target: graph.vertices[(i+1) % 10],
+        weight: i,
+      }
+    end
+
+    # v0 -> v1 -> v2 -> v3 -> v4 -> v5 -> v6 -> v7 -> v8 -> v9
+    #  ^                                                     |
+    #  +-----------------------------------------------------+
+    assert_equal 10, graph.edges.size
+
+    rejected_edges = graph.edges.reject { |edge| edge.weight.odd? }
+
+    assert_equal 10, graph.vertices.size, "Should not change size"
+    assert_equal 10, graph.edges.size,    "Should not change size"
+
+    # v0 -> v1    v2 -> v3    v4 -> v5    v6 -> v7    v8 -> v9
+    assert_equal  5, rejected_edges.size, "edges.size was 10 but deleted 5 edges"
+  end
+
+  def test_build_with_invalid_source
+    v1 = @graph.vertices.build(label: "1")
+    v2 = @graph.vertices.build(label: "2")
+
+    assert_raises(ArgumentError) do
+      @graph.edges.build(target: v2, label: "label")
+    end
+
+    assert_raises(ArgumentError) do
+      @graph.edges.build(source: nil, target: v2, label: "label")
+    end
+  end
+
+  def test_build_with_invalid_target
+    v1 = @graph.vertices.build(label: "1")
+    v2 = @graph.vertices.build(label: "2")
+
+    assert_raises(ArgumentError) do
+      @graph.edges.build(source: v1, label: "label")
+    end
+
+    assert_raises(ArgumentError) do
+      @graph.edges.build(source: v1, target: nil, label: "label")
+    end
+  end
+
+end

data/test/lib/rgraphum/graph_builder_test.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumGraphBuilderTest < MiniTest::Test
+
+  def test_build_from_from_adjacency_matrix
+    labels =   ["hoge","huga","piyo","puyo"] 
+    matrix = [ [  1.0 ,  0.7 ,  0.7 ,  nil ],
+               [  nil ,  1.0 ,  nil ,  0.9 ],
+               [  nil ,  0.8 ,  1.0 ,  0.3 ],
+               [  nil ,  nil ,  nil ,  1.0 ] ]
+
+
+    graph = Rgraphum::Graph.build_from_adjacency_matrix(matrix,labels)
+
+    assert_equal    4,                     graph.edges.size
+
+    rg_assert_equal graph.edges[0].source, graph.vertices[0]
+    rg_assert_equal graph.edges[0].target, graph.vertices[1]
+    rg_assert_equal graph.edges[0].weight, 0.7
+    
+    rg_assert_equal graph.edges[1].source, graph.vertices[0]
+    rg_assert_equal graph.edges[1].target, graph.vertices[2]
+    rg_assert_equal graph.edges[1].weight, 0.7
+
+    rg_assert_equal graph.edges[2].source, graph.vertices[1]
+    rg_assert_equal graph.edges[2].target, graph.vertices[3]
+    rg_assert_equal graph.edges[2].weight, 0.9
+
+    rg_assert_equal graph.edges[3].source, graph.vertices[2]
+    rg_assert_equal graph.edges[3].target, graph.vertices[1]
+    rg_assert_equal graph.edges[3].weight, 0.8
+
+
+    graph = Rgraphum::Graph.build_from_adjacency_matrix(matrix,labels,{:loop=>true,limit:0.8})
+
+    rg_assert_equal graph.edges[0].source, graph.vertices[0]
+    rg_assert_equal graph.edges[0].target, graph.vertices[0]
+    rg_assert_equal graph.edges[0].weight, 1.0
+
+    rg_assert_equal graph.edges[1].source, graph.vertices[1]
+    rg_assert_equal graph.edges[1].target, graph.vertices[1]
+    rg_assert_equal graph.edges[1].weight, 1.0
+
+    rg_assert_equal graph.edges[2].source, graph.vertices[1]
+    rg_assert_equal graph.edges[2].target, graph.vertices[3]
+    rg_assert_equal graph.edges[2].weight, 0.9
+    
+    rg_assert_equal graph.edges[3].source, graph.vertices[2]
+    rg_assert_equal graph.edges[3].target, graph.vertices[1]
+    rg_assert_equal graph.edges[3].weight, 0.8
+
+    rg_assert_equal graph.edges[4].source, graph.vertices[2]
+    rg_assert_equal graph.edges[4].target, graph.vertices[2]
+    rg_assert_equal graph.edges[4].weight, 1.0
+
+    rg_assert_equal graph.edges[5].source, graph.vertices[3]
+    rg_assert_equal graph.edges[5].target, graph.vertices[3]
+    rg_assert_equal graph.edges[5].weight, 1.0
+        
+  end
+end

data/test/lib/rgraphum/graph_dup_test.rb

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumDupTest < MiniTest::Test
+  def setup
+    @graph = Rgraphum::Graph.new
+    @graph.vertices << { id: 1, label: "hoge" }
+    @graph.vertices << { id: 2, label: "huga" }
+    @graph.vertices << { id: 3, label: "piyo" }
+
+    vertices = @graph.vertices
+    @graph.edges << { id: 1, source: vertices[0], target: vertices[1], weight: 1 }
+    @graph.edges << { id: 2, source: vertices[1], target: vertices[2], weight: 1 }
+    @graph.edges << { id: 3, source: vertices[2], target: vertices[0], weight: 1 }
+
+    @vertex_0 = @graph.vertices[0]
+  end
+
+  def test_edge_dup
+    edge_dup = @vertex_0.edges[0].dup
+
+    refute_same @vertex_0.edges[0], edge_dup
+  end
+
+  def test_vertex_edges_dup
+    edges_dup = @vertex_0.edges.dup
+
+    refute_same @vertex_0.edges, edges_dup
+    assert_nil edges_dup.graph
+    assert_nil edges_dup.vertex
+
+    edges_dup.each_with_index do |edge,i|
+      rg_assert_equal edge, @vertex_0.edges[i]
+      refute_same edge, @vertex_0.edges[i]
+    end
+  end
+
+  def test_vertex_dup
+    #  1:hoge --- 2:huga
+    #    \        /
+    #     \      /
+    #     3:piyo
+
+    #  1:hoge----------|
+    #   \ 1':hoge --- 2:huga
+    #    \    |     /
+    #     \   |    /
+    #      \  |   /
+    #       3:piyo
+
+    vertex = @vertex_0.dup
+
+    assert_instance_of Rgraphum::Vertex, vertex
+    refute_same   vertex,  @vertex_0
+
+    refute_empty  vertex.edges
+    rg_assert_equal  vertex.edges.vertex,   vertex
+
+    assert_same   vertex.edges.vertex, vertex
+
+    refute_same  vertex.edges, @vertex_0.edges
+    vertex.edges.each_with_index do |edge,i|
+      rg_assert_equal     edge,           @vertex_0.edges[i]
+      refute_same edge, @vertex_0.edges[i]
+
+      rg_assert_equal vertex, edge.source    unless edge.target == vertex
+      rg_assert_equal vertex, edge.target    unless edge.source == vertex
+      rg_assert_equal @vertex_0, @vertex_0.edges[i].source unless @vertex_0.edges[i].target == @vertex_0
+      rg_assert_equal @vertex_0, @vertex_0.edges[i].target unless @vertex_0.edges[i].source == @vertex_0
+
+      assert       (edge.source.object_id == vertex.object_id or edge.target.object_id == vertex.object_id)
+      assert_same vertex, edge.source unless edge.target.object_id == vertex.object_id
+      assert_same vertex, edge.target unless edge.source.object_id == vertex.object_id
+    end
+
+    # vertex.edges.each do |edge|
+    #   p "vertex"
+    #   p edge.object_id
+    #   p edge
+    # end
+
+    # @graph.vertices.each do |vertex|
+    #   vertex.edges.each do |edge|
+    #     p "graph"
+    #     p edge.object_id
+    #     p edge
+    #   end
+    # end
+  end
+
+  def test_vertices_dup
+    vertices = @graph.vertices.dup
+
+    rg_assert_equal @graph.vertices, vertices
+    assert_nil   vertices.graph
+    refute_same  @graph.vertices, vertices
+
+    [vertices, @graph.vertices].transpose.each do |a, b|
+      assert_instance_of Rgraphum::Vertex, a
+      rg_assert_equal b, a
+      refute_same b, a
+
+      refute_empty a.edges
+      assert_same  a.edges.vertex, a
+
+      refute_same b.edges, a.edges
+
+      a.edges.each do |edge|
+        # assert           i = b.edges.index(edge)
+        i = b.edges.index { |e| e.id == edge.id }
+
+        refute_same b.edges[i], edge
+
+        unless edge.target == a
+          rg_assert_equal a, edge.source
+        end
+
+        unless edge.source == a
+          rg_assert_equal a, edge.target
+        end
+
+        assert edge.source.object_id == a.object_id || edge.target.object_id == a.object_id
+        unless edge.target.object_id == a.object_id
+          assert_same a, edge.source
+        end
+        unless edge.source.object_id == a.object_id
+          assert_same a, edge.target
+        end
+
+        unless b.edges[i].target.object_id == b.object_id
+          assert_same b.edges[i].source, b
+        end
+        unless b.edges[i].source.object_id == b.object_id
+          assert_same b.edges[i].target, b
+        end
+      end
+    end
+  end
+
+  def test_graph_edges_dup
+    edges_dup = @graph.edges.dup
+
+    rg_assert_equal @graph.edges, edges_dup
+    refute_same  @graph.edges, edges_dup
+    assert_nil edges_dup.graph
+    assert_nil edges_dup.vertex
+
+    @graph.vertices.each do |vertex|
+      edges_dup = vertex.edges.dup
+      refute_same vertex.edges, edges_dup
+      assert_nil edges_dup.graph
+      assert_nil edges_dup.vertex
+    end
+  end
+
+  def test_graph_dup
+    duped_graph = @graph.dup
+
+    assert_instance_of Rgraphum::Graph, duped_graph
+    refute_same  duped_graph, @graph
+
+    rg_assert_equal duped_graph.vertices, @graph.vertices
+    refute_same  duped_graph.vertices, @graph.vertices
+
+    rg_assert_equal duped_graph.edges, @graph.edges
+    refute_same  duped_graph.edges, @graph.edges
+
+
+    @graph.vertices.each_with_index do |vertex, vertex_index|
+      duped_vertex = duped_graph.vertices[vertex_index]
+
+      rg_assert_equal duped_vertex, vertex
+      refute_same  duped_vertex, vertex
+
+      vertex.edges.each_with_index do |edge,edge_index|
+        duped_edge = duped_vertex.edges[edge_index]
+
+        rg_assert_equal duped_edge, edge
+        refute_same  duped_edge, edge
+
+        rg_assert_equal duped_edge.source, edge.source
+        refute_same  duped_edge.source, edge.source
+        assert_same  duped_graph.vertices.where(id: duped_edge.source.id).first, duped_edge.source
+
+        rg_assert_equal duped_edge.target, edge.target
+        refute_same  duped_edge.target, edge.target
+      end
+    end
+
+    @graph.edges.each_with_index do |edge,edge_index|
+      duped_edge = duped_graph.edges[edge_index]
+
+      rg_assert_equal duped_edge, edge
+      refute_same  duped_edge, edge
+    end
+  end
+end

data/test/lib/rgraphum/graph_plus_test.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumPlusTest < MiniTest::Test
+  def setup
+    @graph_a = Rgraphum::Graph.new
+    @graph_a.vertices = [
+      { id: 1, label: "hoge" },
+      { id: 2, label: "huga" },
+    ]
+    vertices_a = @graph_a.vertices
+    @graph_a.edges << { id: 1, source: vertices_a[0], target: vertices_a[1], weight: 1}
+    @graph_a.edges << { id: 2, source: vertices_a[1], target: vertices_a[0], weight: 1}
+
+    @graph_b = Rgraphum::Graph.new
+    vertices_b = @graph_b.vertices = [
+      { id: 1, label: "piyo" },
+      { id: 2, label: "hogeratte" },
+    ]
+    vertices_b = @graph_b.vertices
+    @graph_b.edges << { id: 1, source: vertices_b[0], target: vertices_b[1], weight: 1 }
+    @graph_b.edges << { id: 2, source: vertices_b[1], target: vertices_b[0], weight: 1 }
+  end
+
+  def test_add
+    added_graph = @graph_a + @graph_b
+
+    assert_instance_of Rgraphum::Graph, added_graph
+    assert_equal [1,2,3,4], added_graph.vertices.id
+
+    refute_same @graph_a,       added_graph
+    refute_same @graph_a.edges, added_graph.edges
+    refute_same @graph_b,       added_graph
+    refute_same @graph_b.edges, added_graph.edges
+
+    @graph_a.vertices.each_with_index do |vertex, vertex_index|
+      added_vertex = added_graph.vertices[vertex_index]
+
+      rg_assert_equal vertex, added_vertex
+      refute_same  vertex, added_vertex
+
+      vertex.edges.each_with_index do |edge, edge_index|
+        added_edge = added_vertex.edges[edge_index]
+
+        rg_assert_equal edge, added_edge
+        refute_same  edge, added_edge
+
+        rg_assert_equal edge.source,       added_edge.source
+        refute_same  edge.source,       added_edge.source
+        assert_same  added_edge.source, added_graph.vertices.where(id: added_edge.source.id).first
+
+        rg_assert_equal edge.target,       added_edge.target
+        refute_same  edge.target, added_edge.target
+      end
+    end
+
+    @graph_b.vertices.each_with_index do |vertex, vertex_index|
+      added_vertex = added_graph.vertices[vertex_index + 2]
+
+      refute_same  vertex,       added_vertex
+
+      vertex.edges.each_with_index do |edge, edge_index|
+        added_edge = added_vertex.edges[edge_index]
+
+        refute_same edge, added_edge
+
+        assert_equal edge.id + 2,        added_edge.id
+
+        refute_same  edge.source,        added_edge.source
+        assert_same  added_edge.source,  added_graph.vertices.where(id: added_edge.source.id).first
+
+        assert_equal edge.target.id + 2, added_edge.target.id
+        assert_equal edge.target.label,  added_edge.target.label
+        refute_same  edge.target,        added_edge.target
+      end
+    end
+  end
+end