rgraphum 0.0.1.alpha

data/test/lib/rgraphum/importers/idg_json_test.rb

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumImporterIdgJsonTest < MiniTest::Test
+  def test_parse_vertex
+    vertices_json_str = <<-EOT
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"rid": "#6:0", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_1", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }
+  ]
+}
+    EOT
+
+    graph = Rgraphum::Graph.parse(format: :idg_json, vertices: vertices_json_str)
+    assert_equal 1, graph.vertices.size
+    assert_equal 0, graph.edges.size
+
+    vertex = graph.vertices[0]
+    assert_equal "person_1", vertex.label
+  end
+
+  def test_parse_vertices
+    vertices_json_str = <<-EOT
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"rid": "#6:0", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_a", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:1", "@version": 0, 
+"rid": "#6:1", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.99999, 
+"rgb": 99999999, 
+"screen_name": "person_b", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 1, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:2", "@version": 0, 
+"rid": "#6:2", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_c", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }
+  ]
+}
+    EOT
+
+    graph = Rgraphum::Graph.parse(format: :idg_json, vertices: vertices_json_str)
+    assert_equal 3, graph.vertices.size
+    assert_equal 0, graph.edges.size
+
+    assert_equal "person_a", graph.vertices[0].label
+    assert_equal "person_b", graph.vertices[1].label
+    assert_equal "person_c", graph.vertices[2].label
+  end
+
+  def test_parse_vertices_and_edges
+    vertices_json_str = <<-EOT
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"rid": "#6:0", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_a", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:1", "@version": 0, 
+"rid": "#6:1", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.99999, 
+"rgb": 99999999, 
+"screen_name": "person_b", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 1, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:2", "@version": 0, 
+"rid": "#6:2", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_c", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }
+  ]
+}
+    EOT
+
+    edges_json_str = <<-EOT
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"in": "#6:0", 
+"out": "#6:1", 
+"statusIds": "999999999999999999", 
+"weight": 1.0, 
+"created_at": 1373554121, 
+  "@fieldTypes": "weight=f,created_at=l"
+    }, {
+      "@type": "d", "@rid": "#-2:1", "@version": 0, 
+"in": "#6:2", 
+"out": "#6:1", 
+"statusIds": "999999999999999999", 
+"weight": 1.0, 
+"created_at": 1373553637, 
+  "@fieldTypes": "weight=f,created_at=l"
+    }
+  ]
+}
+    EOT
+
+    Rgraphum::Edge.instance_eval {
+      field :created_at # FIXME
+    }
+
+    graph = Rgraphum::Graph.parse(format: :idg_json, vertices: vertices_json_str, edges: edges_json_str)
+    assert_equal 3, graph.vertices.size
+    assert_equal 2, graph.edges.size
+
+    assert_equal "person_a", graph.vertices[0].label
+    assert_equal "person_b", graph.vertices[1].label
+    assert_equal "person_c", graph.vertices[2].label
+
+    assert_equal "person_a", graph.edges[0].source.label
+    assert_equal "person_b", graph.edges[0].target.label
+    assert_equal "2013-07-11 23:48:41 JST", graph.edges[0].created_at.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+    assert_equal "person_c", graph.edges[1].source.label
+    assert_equal "person_b", graph.edges[1].target.label
+    assert_equal "2013-07-11 23:40:37 JST", graph.edges[1].created_at.strftime("%Y-%m-%d %H:%M:%S %Z")
+  end
+
+  def test_load_vertices_and_edges
+    v_path = File.join(File.dirname(__FILE__), "idg_json_vertices.json")
+    e_path = File.join(File.dirname(__FILE__), "idg_json_edges.json")
+
+    graph = Rgraphum::Graph.load(format: :idg_json, vertices: v_path, edges: e_path)
+    assert_equal 3, graph.vertices.size
+    assert_equal 2, graph.edges.size
+
+    assert_equal "person_a", graph.vertices[0].label
+    assert_equal "person_b", graph.vertices[1].label
+    assert_equal "person_c", graph.vertices[2].label
+
+    assert_equal "person_a", graph.edges[0].source.label
+    assert_equal "person_b", graph.edges[0].target.label
+    assert_equal "person_c", graph.edges[1].source.label
+    assert_equal "person_b", graph.edges[1].target.label
+  end
+end

data/test/lib/rgraphum/importers/idg_json_vertices.json

@@ -0,0 +1,46 @@
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"rid": "#6:0", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_a", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:1", "@version": 0, 
+"rid": "#6:1", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.99999, 
+"rgb": 99999999, 
+"screen_name": "person_b", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 1, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }, {
+      "@type": "d", "@rid": "#-2:2", "@version": 0, 
+"rid": "#6:2", 
+"x": 999.99999, 
+"y": 999.99999, 
+"r": 99.999999, 
+"rgb": 99999999, 
+"screen_name": "person_c", 
+"actor_type": 0, 
+"c_id": 0, 
+"c_is_parent": 0, 
+"c_r": 99.999999, 
+"c_rgb": 9999999, 
+  "@fieldTypes": "x=f,y=f,r=f,c_r=f"
+    }
+  ]
+}

data/test/lib/rgraphum/math/average_distance_matrix_test.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumMathAverageDistanceMatrixTest < MiniTest::Test
+  def setup
+    @graph = Rgraphum::Graph.new
+    # @graph.vertices = [
+    #   { label: "A" },
+    #   { label: "B" },
+    #   { label: "C" },
+    #   { label: "D" },
+    #   { label: "G" },
+    # ]
+    @a = @graph.vertices.build(label: "A")
+    @b = @graph.vertices.build(label: "B")
+    @c = @graph.vertices.build(label: "C")
+    @d = @graph.vertices.build(label: "D")
+    @g = @graph.vertices.build(label: "G")
+  end
+
+  # A --(5)-- B --(1)-- G
+  # | ＼      |       ／
+  #(1)  (4)  (2)  (4)
+  # |      ＼ | ／
+  # C --(5)-- D
+  #
+  def test_average_distance_1
+    @graph.edges.build(source: @a, target: @b, weight: 5) # A->B
+    @graph.edges.build(source: @a, target: @c, weight: 1) # A->C
+    @graph.edges.build(source: @a, target: @d, weight: 4) # A->D
+    @graph.edges.build(source: @b, target: @d, weight: 2) # B->D
+    @graph.edges.build(source: @c, target: @d, weight: 5) # C->D
+    @graph.edges.build(source: @b, target: @g, weight: 1) # B->G
+    @graph.edges.build(source: @d, target: @g, weight: 4) # D->G
+
+    average_distance = @graph.average_distance
+
+    n = @graph.vertices.size
+    minimum_distance_matrix = [
+      #  A    B    C    D    G
+      [  0,   5,   1,   4,   6 ], # A
+      [  5,   0,   6,   2,   1 ], # B
+      [  1,   6,   0,   5,   7 ], # C
+      [  4,   2,   5,   0,   3 ], # D
+      [  6,   1,   7,   3,   0 ], # G
+    ]
+    expected = Rational(minimum_distance_matrix.flatten.inject(&:+), n * (n - 1))
+
+    assert_equal expected, average_distance
+  end
+
+  # A --(1)-- B --(4)-- G
+  # | ＼      |       ／
+  #(2)  (4)  (2)  (1)
+  # |      ＼ | ／
+  # C --(3)-- D
+  #
+  def test_average_distance_2
+    @graph.edges.build(source: @a, target: @b, weight: 1) # A->B
+    @graph.edges.build(source: @a, target: @c, weight: 2) # A->C
+    @graph.edges.build(source: @a, target: @d, weight: 4) # A->D
+    @graph.edges.build(source: @b, target: @d, weight: 2) # B->D
+    @graph.edges.build(source: @c, target: @d, weight: 3) # C->D
+    @graph.edges.build(source: @b, target: @g, weight: 4) # B->G
+    @graph.edges.build(source: @d, target: @g, weight: 1) # D->G
+
+    average_distance = @graph.average_distance
+
+    n = @graph.vertices.size
+    minimum_distance_matrix = [
+      #  A    B    C    D    G
+      [  0,   1,   2,   3,   4 ], # A
+      [  1,   0,   3,   2,   3 ], # B
+      [  2,   3,   0,   3,   4 ], # C
+      [  3,   2,   3,   0,   1 ], # D
+      [  4,   3,   4,   1,   0 ], # G
+    ]
+    expected = Rational(minimum_distance_matrix.flatten.inject(&:+), n * (n - 1))
+
+    assert_equal expected, average_distance
+  end
+
+  # A --(5)-- B --(1)-- G
+  # | ＼      |       ／
+  #(1)  (4)  (2)  (4)
+  # |      ＼ | ／
+  # C --(5)-- D
+  #
+  def test_minimum_distance_matrix_1
+    @graph.edges.build(source: @a, target: @b, weight: 5) # A->B
+    @graph.edges.build(source: @a, target: @c, weight: 1) # A->C
+    @graph.edges.build(source: @a, target: @d, weight: 4) # A->D
+    @graph.edges.build(source: @b, target: @d, weight: 2) # B->D
+    @graph.edges.build(source: @c, target: @d, weight: 5) # C->D
+    @graph.edges.build(source: @b, target: @g, weight: 1) # B->G
+    @graph.edges.build(source: @d, target: @g, weight: 4) # D->G
+
+    matrix = @graph.minimum_distance_matrix
+
+    expected = [
+      #  A    B    C    D    G
+      [  0,   5,   1,   4,   6 ], # A
+      [  5,   0,   6,   2,   1 ], # B
+      [  1,   6,   0,   5,   7 ], # C
+      [  4,   2,   5,   0,   3 ], # D
+      [  6,   1,   7,   3,   0 ], # G
+    ]
+
+    assert_equal expected, matrix
+  end
+
+  # A --(1)-- B --(4)-- G
+  # | ＼      |       ／
+  #(2)  (4)  (2)  (1)
+  # |      ＼ | ／
+  # C --(3)-- D
+  #
+  def test_minimum_distance_matrix_2
+    @graph.edges.build(source: @a, target: @b, weight: 1) # A->B
+    @graph.edges.build(source: @a, target: @c, weight: 2) # A->C
+    @graph.edges.build(source: @a, target: @d, weight: 4) # A->D
+    @graph.edges.build(source: @b, target: @d, weight: 2) # B->D
+    @graph.edges.build(source: @c, target: @d, weight: 3) # C->D
+    @graph.edges.build(source: @b, target: @g, weight: 4) # B->G
+    @graph.edges.build(source: @d, target: @g, weight: 1) # D->G
+
+    matrix = @graph.minimum_distance_matrix
+
+    expected = [
+      #  A    B    C    D    G
+      [  0,   1,   2,   3,   4 ], # A
+      [  1,   0,   3,   2,   3 ], # B
+      [  2,   3,   0,   3,   4 ], # C
+      [  3,   2,   3,   0,   1 ], # D
+      [  4,   3,   4,   1,   0 ], # G
+    ]
+
+    assert_equal expected, matrix
+  end
+end

data/test/lib/rgraphum/math/clustering_coefficient_test.rb

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumMathClusteringCoefficientTest < MiniTest::Test
+  def setup
+  end
+
+  def test_local_clustering_coefficient_with_complete_graph
+    # B---C
+    # |\ /|
+    # | A |
+    # \ | /
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+    graph.edges.build(source: c, target: d)
+    graph.edges.build(source: d, target: b)
+
+    # B - C  B\    /C
+    #  \ /   | A  A |
+    #   A    D/    \D
+    assert_equal "3/3".to_r, a.clustering_coefficient
+    # B - C  B\        B - C
+    #  \ /   | A        \ /
+    #   A    D/          D
+    assert_equal "3/3".to_r, b.clustering_coefficient
+    # B - C        /C  B - C
+    #  \ /        A |   \ /
+    #   A          \D    D
+    assert_equal "3/3".to_r, c.clustering_coefficient
+    #        B\    /C  B - C
+    #        | A  A |   \ /
+    #        D/    \D    D
+    assert_equal "3/3".to_r, d.clustering_coefficient
+  end
+
+  def test_local_clustering_coefficient_with_non_complete_graph_1
+    # B---C
+    #  \ /
+    #   A
+    #   |
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+
+    # B - C  B\    /C
+    #  \ /     A  A
+    #   A    D/    \D
+    assert_equal "1/3".to_r, a.clustering_coefficient
+    # B - C
+    #  \ /
+    #   A
+    assert_equal "1/1".to_r, b.clustering_coefficient
+    # B - C
+    #  \ /
+    #   A
+    assert_equal "1/1".to_r, c.clustering_coefficient
+    #
+    #
+    #
+    assert_equal "0".to_r, d.clustering_coefficient
+  end
+
+  def test_local_clustering_coefficient_with_non_complete_graph_2
+    # B---C
+    #  \ /|
+    #   A |
+    #   |/
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+    graph.edges.build(source: c, target: d)
+
+    # B - C  B\    /C
+    #  \ /     A  A |
+    #   A    D/    \D
+    assert_equal "2/3".to_r, a.clustering_coefficient
+    # B - C
+    #  \ /
+    #   A
+    assert_equal "1/1".to_r, b.clustering_coefficient
+    # B - C        /C  B - C
+    #    /        A |   \ /
+    #   A          \D    D
+    assert_equal "2/3".to_r, c.clustering_coefficient
+    #              /C
+    #             A |
+    #              \D
+    assert_equal "1/1".to_r, d.clustering_coefficient
+  end
+
+  def test_global_clustering_coefficient_with_complete_graph
+    # B---C
+    # |\ /|
+    # | A |
+    # \ | /
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+    graph.edges.build(source: c, target: d)
+    graph.edges.build(source: d, target: b)
+
+    # assert_equal "3/3".to_r, a.clustering_coefficient
+    # assert_equal "3/3".to_r, b.clustering_coefficient
+    # assert_equal "3/3".to_r, c.clustering_coefficient
+    # assert_equal "3/3".to_r, d.clustering_coefficient
+
+    # N: 4
+    #         N
+    # 1/N * Σ Ci
+    #        i=0
+    #
+    # 1/4 * (3/3 + 3/3 + 3/3 + 3/3) = 1
+    assert_equal "1".to_r, graph.clustering_coefficient
+  end
+
+  def test_global_clustering_coefficient_with_non_complete_graph_1
+    # B---C
+    #  \ /
+    #   A
+    #   |
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+
+    # assert_equal "1/3".to_r, a.clustering_coefficient
+    # assert_equal "1/1".to_r, b.clustering_coefficient
+    # assert_equal "1/1".to_r, c.clustering_coefficient
+    # assert_equal "0".to_r, d.clustering_coefficient
+
+    # N: 4
+    #         N
+    # 1/N * Σ Ci
+    #        i=0
+    #
+    # 1/4 * (1/3 + 1/1 + 1/1 + 0) = 1/4 * (7/3) = 7/12
+    assert_equal "7/12".to_r, graph.clustering_coefficient
+  end
+
+  def test_global_clustering_coefficient_with_non_complete_graph_2
+    # B---C
+    #  \ /|
+    #   A |
+    #   |/
+    #   D
+    graph = Rgraphum::Graph.new
+    a = graph.vertices.build(label: "A")
+    b = graph.vertices.build(label: "B")
+    c = graph.vertices.build(label: "C")
+    d = graph.vertices.build(label: "D")
+
+    graph.edges.build(source: a, target: b)
+    graph.edges.build(source: a, target: c)
+    graph.edges.build(source: a, target: d)
+
+    graph.edges.build(source: b, target: c)
+    graph.edges.build(source: c, target: d)
+
+    # assert_equal "2/3".to_r, a.clustering_coefficient
+    # assert_equal "1/1".to_r, b.clustering_coefficient
+    # assert_equal "2/3".to_r, c.clustering_coefficient
+    # assert_equal "1/1".to_r, d.clustering_coefficient
+
+    # N: 4
+    #         N
+    # 1/N * Σ Ci
+    #        i=0
+    #
+    # 1/4 * (2/3 + 1/1 + 2/3 + 1/1) = 1/4 * (4/3 + 2/1) = 1/4 * (10/3) = 10/12 = 5/6
+    assert_equal "5/6".to_r, graph.clustering_coefficient
+  end
+end

data/test/lib/rgraphum/math/community_test.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+require 'rgraphum'
+
+class RgraphumMathCommunityTest < MiniTest::Test
+  def setup
+    #  1 - 2
+    #   \ /
+    #    3
+    #   / \
+    #  4 - 5
+
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [
+      { id: 1, label: "A", community_id: 1 },
+      { id: 2, label: "B", community_id: 1 },
+      { id: 3, label: "C" },
+      { id: 4, label: "D" },
+      { id: 5, label: "E" },
+    ]
+    @graph.edges = [
+      { id: 0, source: 1, target: 2, weight: 1 },
+      { id: 1, source: 1, target: 3, weight: 1 },
+      { id: 2, source: 2, target: 3, weight: 1 },
+      { id: 3, source: 3, target: 4, weight: 1 },
+      { id: 4, source: 3, target: 5, weight: 1 },
+      { id: 5, source: 4, target: 5, weight: 1 },
+    ]
+  end
+
+  def test_community
+    #  1 - 2
+    #   \ /
+    #    3
+    #   / \
+    #  4 - 5
+    # (1-2) communityy
+
+    @graph.id_aspect!
+    community = @graph.communities[0]
+
+    assert community
+    assert_instance_of Rgraphum::Community, community
+    assert_equal 1, community.id
+    expected = [
+      { id: 0, source: 1, target: 2, weight: 1 },
+      { id: 1, source: 1, target: 3, weight: 1 },
+      { id: 2, source: 2, target: 3, weight: 1 },
+    ]
+    rg_assert_equal expected, community.edges
+
+    rg_assert_equal [{ id: 0, source: 1, target: 2, weight: 1 }], community.inter_edges
+    expected = [
+      { id: 1, source: 1, target: 3, weight: 1 },
+      { id: 2, source: 2, target: 3, weight: 1 },
+    ]
+    rg_assert_equal expected, community.edges_from(@graph.vertices.where(id: 3).first)
+    assert_empty community.edges_from(@graph.vertices.where(id: 4).first)
+
+    @graph.edges.where(id: 0).first.weight = 4
+    @graph.edges.where(id: 1).first.weight = 1
+    @graph.edges.where(id: 2).first.weight = 2
+    @graph.edges.where(id: 3).first.weight = 3
+    @graph.edges.where(id: 4).first.weight = 5
+    @graph.edges.where(id: 5).first.weight = 6
+
+    assert_equal 11, community.degree_weight
+    assert_equal 4,  community.sigma_in
+
+    assert_equal 11, @graph.vertices.where(id: 3).first.sigma_tot
+
+    @graph.real_aspect!
+    rmcd = Rgraphum::Graph::Math::CommunityDetection.new(@graph)
+    delta_q = rmcd.delta_q(community,@graph.vertices.where(id: 3).first)
+    assert_in_delta 0.00566893, delta_q, 0.00000001
+  end
+end