rgraphum 0.0.1.alpha

data/lib/rgraphum/graph/math/clustering_coefficient.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+module Rgraphum::Graph::Math::ClusteringCoefficient
+  def self.included(base)
+    base.extend ClassMethods
+    base::RGRAPHUM::Vertex.send :include, VertexMethods
+  end
+
+  # Global clustering coefficient
+  #
+  # Returns clustering coefficient in Rational
+  #
+  def clustering_coefficient
+    n = vertices.size
+    # vertices.inject(0) { |cc, vertex|
+    #   cc + (vertex.clustering_coefficient / n)
+    # }
+    sum_of_local_clustering_coefficient = vertices.inject(0) { |cc, vertex|
+      cc + (vertex.clustering_coefficient)
+    }
+    sum_of_local_clustering_coefficient / n
+  end
+
+  module ClassMethods
+  end
+
+  module VertexMethods
+    # Local clustering coefficient
+    #
+    # <pre>
+    # open triplet    closed triplet
+    #  V1   V2         V1 - V2
+    #   \   /           \   /
+    #    V3              V3
+    # </pre>
+    #
+    def clustering_coefficient
+      ajacency_vertices = both
+      return Rational(0) if ajacency_vertices.size < 2
+      num_open_triplets, num_close_triplets = 0, 0
+      ajacency_vertices.combination(2) do |(v1, v2)|
+        va, vb = v1, v2
+        va, vb = v2, v1 if v1.edges.size > v2.edges.size
+        if va.edges.any? { |e| e.bothV.include?(vb) }
+          num_close_triplets += 1
+        else
+          num_open_triplets += 1
+        end
+      end
+      Rational(num_close_triplets, num_open_triplets + num_close_triplets)
+    end
+  end
+end

data/lib/rgraphum/graph/math/community_detection.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+
+module  Rgraphum::Graph::Math
+end
+
+# Community Detection by Girvan?Newman algorithm
+#   1st Set all vertex on each uniq communiy
+#   2nd find edges within communities and make communities pair 
+#   3rd calc delta_q if marge communities pair 
+#   4th max delta_q communities pair is marged
+#   5th update delta_q and do 4th
+#   6th if dalta_q <= limit, stop community detection
+class Rgraphum::Graph::Math::CommunityDetection
+
+  def initialize(graph,limit = 0)
+    @graph       = graph
+    @m           = graph.m_with_weight
+    @limit       = 0
+
+    @modularity = 0
+    @id_community_hash = {}
+    initial_modularity_and_communities
+    @delta_q_hash = {}
+    initial_delta_q_hash
+
+  end
+
+  # modularity
+  # main loop of community_detection and cale modularity with delta_q( = delta_modularity )
+  #
+  def modularity
+
+    loop do
+      (community_id_a, community_id_b), delta_q = @delta_q_hash.max { |a, b| a[1] <=> b[1] }
+
+      break unless community_id_a && community_id_b && delta_q
+      break if delta_q <= @limit
+
+      @modularity += delta_q / (2.0 * @m ** 2)
+
+      community_a = @id_community_hash[community_id_a]
+      community_b = @id_community_hash[community_id_b]
+
+      community_a.merge(community_b)
+      @delta_q_hash = update_delta_q_hash(community_id_a, community_id_b, @delta_q_hash)
+    end
+
+    @modularity
+  end
+
+  
+  def initial_modularity_and_communities
+
+    @graph.vertices.each_with_index do |vertex, i|
+      vertex.community_id = i
+      unless vertex.edges == []
+        community = Rgraphum::Community.new(id: vertex.community_id, graph: self, vertices: [vertex])
+        @id_community_hash[i] = community
+        @modularity -= vertex.degree_weight.to_f ** 2 / (2.0 * @m ) ** 2
+      end
+    end
+
+  end
+
+  # delta_q_hash: Hash
+  #   key:   [community_a.id, community_b.id] # Array of Integer
+  #   value: delta_q_seed # Float
+  def initial_delta_q_hash( limit=0 )
+    @graph.edges.each do |edge|
+      s_c_id = edge[:source].community_id
+      t_c_id = edge[:target].community_id
+
+      # don't use loop
+      next if s_c_id == t_c_id
+
+      key = [ s_c_id, t_c_id ].sort!
+
+      delta_q_seed = delta_q_seed( @id_community_hash[ key[0] ] , @id_community_hash[ key[1] ] )
+      next if delta_q_seed <= limit
+      @delta_q_hash[key] = delta_q_seed
+    end
+  end
+
+
+  # ΔQ = Qa - Qb
+  def delta_q(community_a, community_b)
+    seed = delta_q_seed(community_a, community_b)
+    seed / (2.0 * @m ** 2)
+  end
+
+  private
+
+  def update_delta_q_hash(community_id_a, community_id_b, delta_q_hash)
+    a_id = community_id_a
+    b_id = community_id_b
+
+    new_keys = []
+    used_keys = []
+
+    # b_id -> a_id
+    @delta_q_hash.delete_if do |key,value|
+      next true if key == [a_id,b_id]
+      next false unless index = key.index(b_id)
+
+      key_dup = key.dup
+      key_dup[index] = a_id
+      
+      key_dup.sort!
+      new_keys << key_dup
+    end
+
+    new_keys.each do |key|
+      @delta_q_hash[key] = 0.0
+    end
+
+    # update delta_q_value
+    community_a = @id_community_hash[a_id]
+    @delta_q_hash.each do |key, value|
+      if a_key_index = key.index(a_id)
+        o_key_index = a_key_index - 1
+        o_id = key[o_key_index]
+        other_community = @id_community_hash[o_id]
+
+        delta_q_seed = delta_q_seed(community_a, other_community)
+        next if delta_q_seed <= @limit
+        @delta_q_hash[key] = delta_q_seed
+      end
+    end
+
+    @delta_q_hash
+  end
+
+  def delta_q_seed(community_a, community_b)
+    tot_i = community_a.degree_weight
+    tot_j = community_b.degree_weight
+
+    ki_in = community_a.edges_from(community_b).inject(0) { |sum, edge| sum + edge.weight }
+
+    2.0 * @m * ki_in - tot_i * tot_j
+  end
+end

data/lib/rgraphum/graph/math/degree_distribution.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+module Rgraphum::Graph::Math
+
+  class DegreeDistribution
+    attr_reader :degree_distribution
+
+    def initialize(graph)
+      degree_distribution = {}
+
+      graph.vertices.each do |vertex|
+        degree_distribution[vertex.degree] ||= 0
+        degree_distribution[vertex.degree] += 1
+      end
+
+      @degree_distribution = {}
+      degree_distribution.each do |key, value|
+        @degree_distribution[key] = value.to_f / graph.vertices.size
+      end
+
+      self
+    end
+
+    def exponent
+      loged_degree_distribution = to_log
+      ral = Rgraphum::Analyzer::LinearRegression.new
+      ral.analyze(loged_degree_distribution.keys, loged_degree_distribution.values).first
+    end
+
+    def to_log
+      output ={}
+      @degree_distribution.each do |key,value|
+        output[Math.log(key, 10)] = Math.log(value, 10)
+      end
+      output
+    end
+  end
+
+  def degree_distribution(force=false)
+    @degree_distribution = nil if force
+    @degree_distribution ||= DegreeDistribution.new(self)
+    @degree_distribution.degree_distribution
+  end
+
+  def degree_distribution_exponent(force=false)
+    @degree_distribution = nil if force
+    @degree_distribution ||= DegreeDistribution.new(self)
+    @degree_distribution.exponent
+  end
+end

data/lib/rgraphum/graph/math/dijkstra.rb

@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+
+# A --(1)-- B --(4)-- G
+# | ＼      |       ／
+#(2)  (4)  (2)  (1)
+# |      ＼ | ／
+# C --(3)-- D
+#
+# A -> B -> D -> G
+#
+#
+# \ A B C D G
+# A - 1 2 4 -
+# B 1 - - 2 4
+# C 2 - - 3 -
+# D 4 2 3 - 1 
+# G - 4 - 1 -
+#
+# \ A B C D G
+# A - 1 2 4 -
+# B - - - 2 4
+# C - - - 3 -
+# D - - - - 1 
+# G - - - - -
+#
+# \ A B C D G
+# A - 1 2 4 -
+# B - - - 2 4
+# C - - - 3 -
+# D - - - - 1 
+# G - - - - -
+#
+# A-B 1
+# A-C 2
+# A-D 4
+#
+# A-B-D 1+2=3
+# A-B-G 1+4=5
+# A-C       1
+# A-D       4
+#
+# A-B-D 1+2=3
+# A-B-G 1+4=5
+# A-C-D 1+3=4
+# A-D       4
+#
+# A-B-D 1+2=3
+# A-B-G 1+4=5
+# A-C-D 1+3=4 x
+# A-D       4
+#
+# A-B-D-G 1+2+1=4
+# A-B-G   1+4  =5 x
+# A-C-D   1+3  =4 x
+# A-D           4 x
+#
+module Rgraphum::Graph::Math::Dijkstra
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  # Find shortest route from start to end
+  #
+  # Returns array of vertices
+  #
+  def dijkstra(start_vertex, end_vertex)
+    self.class.dijkstra(self, start_vertex, end_vertex)
+  end
+
+  def adjacency_matrix
+    self.class.adjacency_matrix(self)
+  end
+
+  def average_distance
+    self.class.average_distance(self)
+  end
+
+  def quick_average_distance
+    self.class.quick_average_distance(self)
+  end
+
+  def minimum_distance_matrix
+    self.class.minimum_distance_matrix(self)
+  end
+
+  module ClassMethods
+    # class Route
+    #   attr_reader :id
+    #   attr_accessor :vertices, :total_weight, :ended
+    #
+    #   def initialize(vertex, options={})
+    #     weight = options[:weight] || 1
+    #     end_vertex = options[:end_vertex]
+    #     end_id = end_vertex ? end_vertex.id : options[:end_id]
+    #     if options.key?(:start_vertex)
+    #       start_vertex = options[:start_vertex]
+    #       @id = vertex.id
+    #       @vertices = [start_vertex, vertex]
+    #       @total_weight = weight
+    #       @ended = (id == end_id)
+    #     elsif options.key?(:route)
+    #       route = options[:route]
+    #       @id = vertex.id
+    #       @vertices = route[:vertices] + [vertex]
+    #       @total_weight = route[:total_weight] + weight
+    #       @ended = (id == end_id)
+    #     else
+    #       raise ArgumentError
+    #     end
+    #   end
+    # end
+
+    # Find shortest route from start to end
+    #
+    # Returns array of vertices
+    #
+    def dijkstra(graph, start_vertex, end_vertex)
+      details = dijkstra_details(graph, start_vertex, end_vertex)
+      routes = details[:routes]
+
+      return [] if routes.nil? || routes.empty?
+      routes[0][:vertices]
+    end
+
+    # Find shortest routes from start to end
+    #
+    # Returns routes
+    #
+    def dijkstra_details(graph, start_vertex, end_vertex)
+      return {} if start_vertex.id == end_vertex.id
+
+      end_id = end_vertex.id
+      size = graph.vertices.size
+
+      shortest_map = Array.new(size, Float::INFINITY)
+      adjacency_matrix = adjacency_matrix(graph)
+
+      routes = []
+
+      start_index = graph.vertices.index(start_vertex)
+      weights = adjacency_matrix[start_index]
+      weights.each_with_index do |weight, i|
+        next unless weight
+        shortest_map[i] = weight
+
+        vertex = graph.vertices[i]
+        routes << {
+          id: vertex.id,
+          index: i,
+          vertices: [start_vertex, vertex],
+          weights: [weight],
+          total_weight: weight,
+          ended: vertex.id == end_id,
+        }
+      end
+
+      loop do
+        shortest_route = routes.min_by { |route|
+          route[:ended] ? Float::INFINITY : route[:total_weight]
+        }
+        break if !shortest_route || shortest_route[:ended]
+
+        routes.delete shortest_route
+        weights = adjacency_matrix[shortest_route[:index]]
+        weights.each_with_index do |weight, i|
+          next unless weight
+          vertex = graph.vertices[i]
+          next if shortest_route[:vertices].include?(vertex)
+
+          total_weight = shortest_route[:total_weight] + weight
+          next if shortest_map[i] < total_weight
+          shortest_map[i] = total_weight
+
+          routes << {
+            id: vertex.id,
+            index: i,
+            vertices: shortest_route[:vertices] + [vertex],
+            weights: shortest_route[:weights] + [weight],
+            total_weight: shortest_route[:total_weight] + weight,
+            ended: vertex.id == end_id,
+          }
+        end
+
+        remove_long_routes routes
+      end
+
+      {
+        graph: graph,
+        start_vertex: start_vertex,
+        end_vertex: end_vertex,
+        routes: routes,
+        shortest_map: shortest_map,
+        adjacency_matrix: adjacency_matrix,
+      }
+    end
+
+    # 隣接行列 Adjacency matrix
+    def adjacency_matrix(graph)
+      ids = graph.vertices.map(&:id)
+      id_index_map = Hash[*ids.map.with_index { |id, i| [id, i] }.flatten]
+      size = graph.vertices.size
+      adjacency_matrix = (0...size).map { Array.new(size) }
+
+      graph.edges.each do |e|
+        i = id_index_map[e.source.id]
+        j = id_index_map[e.target.id]
+        adjacency_matrix[i][j] = e.weight
+        adjacency_matrix[j][i] = e.weight # FIXME
+      end
+
+      adjacency_matrix
+    end
+
+    def average_distance_with_minimum_distance_matrix(graph, &block)
+      minimum_distance_matrix = yield
+      n = minimum_distance_matrix.size
+      total_minimum_distane = 0
+      (0...n).each do |i|
+        ((i+1)...n).each do |j|
+          total_minimum_distane += minimum_distance_matrix[i][j]
+        end
+      end
+      Rational(total_minimum_distane, Rational(n * (n-1), 2))
+    end
+
+    def average_distance(graph)
+      average_distance_with_minimum_distance_matrix(graph) {
+        minimum_distance_matrix(graph)
+      }
+    end
+
+    def quick_average_distance(graph)
+      average_distance_with_minimum_distance_matrix(graph) {
+        quick_minimum_distance_matrix(graph)
+      }
+    end
+
+    def minimum_distance_matrix(graph)
+      size = graph.vertices.size
+      distance_matrix = (0...size).map { Array.new(size) }
+
+      (0...size).each do |i|
+        (i...size).each do |j|
+          if i == j
+            distance = 0
+          else
+            v1, v2 = graph.vertices[i], graph.vertices[j]
+            details = dijkstra_details(graph, v1, v2)
+            weights = details[:routes][0][:weights] rescue []
+            if weights.empty?
+              distance = nil
+            else
+              distance = weights.inject(0, &:+)
+            end
+          end
+          distance_matrix[i][j] = distance
+        end
+      end
+
+      (0...(size-1)).each do |i|
+        ((i+1)...size).each do |j|
+          distance_matrix[j][i] = distance_matrix[i][j]
+        end
+      end
+
+      distance_matrix
+    end
+
+    def quick_minimum_distance_matrix(graph)
+      size = graph.vertices.size
+      distance_matrix = (0...size).map { Array.new(size) }
+
+      remaining_paths = {}
+      (0...(size-1)).each do |i|
+        ((i+1)...size).each do |j|
+          remaining_paths[[i, j]] = true
+        end
+      end
+
+      until remaining_paths.empty?
+        (i, j), _ = remaining_paths.shift
+        v1, v2 = graph.vertices[i], graph.vertices[j]
+        
+        details = dijkstra_details(graph, v1, v2)
+        weights = details[:routes][0][:weights] rescue []
+        if weights.empty?
+          distance_matrix[i][j] = nil
+        else
+          route_vertices = details[:routes][0][:vertices]
+          route_vertices_size = route_vertices.size
+
+          (0...(route_vertices_size-1)).each do |k|
+            ((k+1)...route_vertices_size).each do |l|
+              m = graph.vertices.index(route_vertices[k])
+              n = graph.vertices.index(route_vertices[l])
+              m, n = n, m if m > n
+              unless distance_matrix[m][n]
+                distance_matrix[m][n] = weights[k..l].inject(0, &:+)
+                remaining_paths.delete [m, n]
+              end
+            end
+          end
+        end
+      end
+
+      (0...size).each do |i|
+        distance_matrix[i][i] = 0
+      end
+      (0...(size-1)).each do |i|
+        ((i+1)...size).each do |j|
+          distance_matrix[j][i] = distance_matrix[i][j]
+        end
+      end
+
+      distance_matrix
+    end
+
+    def remove_long_routes(routes)
+      ended_routes = routes.select { |route| route[:ended] }
+      shortest_ended_route = ended_routes.min_by { |route| route[:total_weight] }
+
+      if shortest_ended_route
+        routes.reject! do |route|
+          shortest_ended_route[:total_weight] < route[:total_weight]
+        end
+      end
+    end    
+  end
+
+  private
+end

data/lib/rgraphum/graph/math.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+class Rgraphum::Graph
+end
+
+module Rgraphum::Graph::Math
+  require_relative 'math/dijkstra'
+  require_relative 'math/clustering_coefficient'
+  require_relative 'math/degree_distribution'
+  require_relative 'math/community_detection'
+
+  def self.included(base)
+    # base.extend ClassMethods
+    base.send :include, Rgraphum::Graph::Math::Dijkstra
+    base.send :include, Rgraphum::Graph::Math::ClusteringCoefficient
+  end
+
+  def modularity
+    CommunityDetection.new(self).modularity
+  end
+
+  def communities
+    existing_community_ids = {}
+    communities = []
+    @vertices.each do |vertex|
+      next if existing_community_ids.key?(vertex.community_id)
+      community = community_by_id(vertex.community_id)
+      communities << community
+      existing_community_ids[community.id] = true
+    end
+    Rgraphum::Communities(communities)
+  end
+
+  def power_low_rand(max,min,exponent)
+    ( (max^exponent-min^exponent)*rand() + min^exponent )^( 1.0/exponent )
+  end
+
+  private
+
+  def community_by_id(community_id)
+    community_id = community_id.id if community_id.is_a?(Rgraphum::Community)
+    vertices = @vertices.find_all { |vertex| vertex.community_id == community_id }
+    Rgraphum::Community.new(id: community_id, graph: self, vertices: vertices)
+  end
+
+end