rgraphum 0.0.1.alpha

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rgraphum.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 ice
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,136 @@
+# Rgraphum
+
+rgraphum is the open source for graph and complicated network analysis written by ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rgraphum'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rgraphum
+
+## Usage
+
+![rgraphum-struct](graph_struct.jpg)
+
+rgraphum is framework and a console application for analysis of graph and complex network.
+It is made of ruby, you can accept the code of ruby.
+Now, let’s see while using the console application an overview.
+
+start console application
+
+    $ rgraphum_console
+
+#### graph structure of rgraphum (new, added, traverse)
+
+By creating an instance of the Graph class, rgraphum will have the entity graph.
+graph = Graph.new
+Instance of Graph will have an instance of Vertices and an instance of the Edges, such as Array.
+graph.vertices
+graph.edges
+(An array of empty initial both)
+
+When adding vertex or edge, it is operation on vertices, edges, and vertex.edges.
+vertex or edge is specified in an instance such as the Hash.
+
+    v_a = graph.vertices.build(label:"A")
+    v_b = graph.vertices.build(label:"B")
+    graph.edges.build(source:v_a,target:v_b)
+    v_a.edges.build(source:v_b,target:v_a)
+
+vertex will have edges being like a Array.
+edge in the edges refers to the object.
+This is the same as the one in the edges of the graph.
+
+    v_a.edges
+    e_a_b = v_a.edges[0]
+    graph.edges
+    graph.edges[0].object_id
+    e_a_b.object_id
+
+edge has a target and source, these are objects of vertex.
+This is the same as the one in the graph.vertices.
+
+    s_v= e_a_b.source
+    t_v = e_a_b.target
+    s_v.object_id
+    t_v.object_id
+    graph.vertices[0].object_id
+    graph.vertices[1].object_id
+
+#### search
+
+search is done in graph.vertices, graph.edges, and vertex.edges.
+
+    v_a = graph.vertices.where(label:"A").first
+    v_a = graph.vertices.where(label:"A")[0]
+    e_a_b = graph.edges.where(source:v_a).first
+    e_a_b = v_a.edges.where(source:v_a).first
+
+#### delete
+
+Delete as well, do in graph.vertices, graph.edges, and vertex.edges.
+
+    graph.edges
+    v_a.edges
+    e_b_a = v_a.edges[1]
+    v_a.delete(e_b_a)
+    v_a.edges
+
+    graph.edges
+    v_a.edges
+    e_a_b = v_a.edges[0]
+    graph.edges.delete(e_a_b)
+    v_a.edges
+
+    graph.vertices
+    graph.vertices.delete(v_a)
+    graph.vertices
+
+#### sample
+
+As a sample, The graph above, on the console, was made the following script.
+
+
+    graph = Graph.new
+    v_g = graph.vertices.build(label:"Graph")
+    v_vs = graph.vertices.build(label:"Vertices")
+    v_es = graph.vertices.build(label:"Edges")
+    graph.edges.build(source:v_g,target:v_vs)
+    graph.edges.build(source:v_g,target:v_es)
+
+    v_v = graph.vertices.build(label:"Vertex")
+    v_e = graph.vertices.build(label:"Edge")
+    graph.edges.build(source:v_vs,target:v_v)
+    graph.edges.build(source:v_es,target:v_e)
+
+    v_v_es = graph.vertices.build(label:"Vertex.edges")
+    graph.edges.build(source:v_v,target:v_v_es)
+    graph.edges.build(source:v_v_es,target:v_e)
+
+    v_e_s = graph.vertices.build(label:"Edge.source")
+    v_e_t = graph.vertices.build(label:"Edge.target")
+    graph.edges.build(source:v_e,target:v_e_s)
+    graph.edges.build(source:v_e,target:v_e_t)
+    graph.edges.build(source:v_e_s,target:v_v)
+    graph.edges.build(source:v_e_t,target:v_v)
+
+    Parsers::GraphvizParser.export(graph,"graph_struct","jpg")
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+# require 'pry'
+# require 'pry-nav'
+# require 'pry-exception_explorer'
+# require 'pry-stack_explorer'
+# require 'pry-coolline'
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.libs << "lib"
+  t.libs << "test"
+end

data/bin/.irbrc

@@ -0,0 +1,41 @@
+# -*- mode: ruby coding: utf-8 -*-
+
+IRB.conf[:IRB_NAME] = "rgraphum"
+
+# :DEFAULT => {
+#   :PROMPT_I => "%N(%m):%03n:%i> ",
+#   :PROMPT_N => "%N(%m):%03n:%i> ",
+#   :PROMPT_S => "%N(%m):%03n:%i%l ",
+#   :PROMPT_C => "%N(%m):%03n:%i* ",
+#   :RETURN => "=> %s\n"
+# },
+IRB.conf[:PROMPT][:RGRAPHUM] = {
+  :PROMPT_I => "%N(%m):%03n:%i> ",
+  :PROMPT_N => "%N(%m):%03n:%i> ",
+  :PROMPT_S => "%N(%m):%03n:%i%l ",
+  :PROMPT_C => "%N(%m):%03n:%i* ",
+  :RETURN => "=> %s\n"
+}
+# IRB.conf[:PROMPT_MODE] = :RGRAPHUM
+IRB.conf[:AUTO_INDENT] = true
+
+puts "Welcome to Rgraphum!"
+puts
+puts "This is an example for Rgraphum"
+puts
+puts "> graph = Graph.new"
+puts ">"
+puts "> vertex1 = graph.vertices.build(label: \"Vertex 1\")"
+puts "> vertex2 = graph.vertices.build(label: \"Vertex 2\")"
+puts "> vertex3 = graph.vertices.build(label: \"Vertex 3\")"
+puts "> "
+puts "> edge1 = graph.edges.build(source: vertex1, target: vertex2, weight: 1)"
+puts "> edge2 = graph.edges.build(source: vertex2, target: vertex3, weight: 1)"
+puts "> edge3 = graph.edges.build(source: vertex3, target: vertex1, weight: 1)"
+puts "> "
+puts "> open('sample.gexf', 'w') do |f|"
+puts ">   f.puts graph.to_gephi"
+puts "> end"
+puts
+puts "Enter 'quit' to exit."
+puts

data/bin/rgraphum_console

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby coding: utf-8 -*-
+
+require 'optparse'
+require 'fileutils'
+require 'irb'
+require 'irb/completion'
+
+begin
+  require 'rgraphum'
+rescue LoadError
+  require_relative "../lib/rgraphum"
+end
+
+include Rgraphum
+
+options = {}
+
+ARGV.clone.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: rgraphum_console [options]"
+
+  opts.separator ""
+
+  opts.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = true }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { $stdout.puts opts; exit }
+
+  opts.separator ""
+  opts.separator "> graph = Graph.new"
+  opts.separator ">"
+  opts.separator "> vertex1 = graph.vertices.build(label: \"Vertex 1\")"
+  opts.separator "> vertex2 = graph.vertices.build(label: \"Vertex 2\")"
+  opts.separator "> vertex3 = graph.vertices.build(label: \"Vertex 3\")"
+  opts.separator "> "
+  opts.separator "> edge1 = graph.edges.build(source: vertex1, target: vertex2, weight: 1)"
+  opts.separator "> edge2 = graph.edges.build(source: vertex2, target: vertex3, weight: 1)"
+  opts.separator "> edge3 = graph.edges.build(source: vertex3, target: vertex1, weight: 1)"
+  opts.separator "> "
+  opts.separator "> open('sample.gexf', 'w') do |f|"
+  opts.separator ">   f.puts graph.to_gephi"
+  opts.separator "> end"
+
+  opts.parse!
+end
+
+if options[:debugger]
+  begin
+    require 'ruby-debug'
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end
+
+ENV['IRBRC'] = File.join(File.dirname(__FILE__), '.irbrc')
+
+IRB.start

data/bin/rgraphum_runner

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby coding: utf-8 -*-
+
+require 'optparse'
+begin
+  require 'rgraphum'
+rescue LoadError
+  require_relative "../lib/rgraphum"
+end
+include Rgraphum
+
+code_or_file = nil
+
+if ARGV.first.nil?
+  ARGV.push "-h"
+end
+
+ARGV.clone.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: rgraphum_runner [options] ('Some.ruby(code)' or a filename)"
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { $stdout.puts opts; exit }
+
+  opts.separator ""
+  opts.separator "$ cat sample.rb"
+  opts.separator "graph = Rgraphum::Graph.new"
+  opts.separator ""
+  opts.separator "vertex1 = graph.vertices.build(label: \"Vertex 1\")"
+  opts.separator "vertex2 = graph.vertices.build(label: \"Vertex 2\")"
+  opts.separator "vertex3 = graph.vertices.build(label: \"Vertex 3\")"
+  opts.separator ""
+  opts.separator "edge1 = graph.edges.build(source: vertex1, target: vertex2, weight: 1)"
+  opts.separator "edge2 = graph.edges.build(source: vertex2, target: vertex3, weight: 1)"
+  opts.separator "edge3 = graph.edges.build(source: vertex3, target: vertex1, weight: 1)"
+  opts.separator ""
+  opts.separator "open('sample.gexf', 'w') do |f|"
+  opts.separator "  f.puts graph.to_gephi"
+  opts.separator "end"
+  opts.separator ""
+  opts.separator "$ rgraphum_runner example.rb"
+
+  opts.order! { |o| code_or_file ||= o } rescue retry
+end
+
+ARGV.delete(code_or_file)
+
+if code_or_file.nil?
+  $stderr.puts "Run '#{$0} -h' for help."
+  exit 1
+elsif File.exist?(code_or_file)
+  $0 = code_or_file
+  eval(File.read(code_or_file), nil, code_or_file)
+else
+  eval(code_or_file)
+end

data/examples/ba_model/make.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../../lib/rgraphum'
+require 'csv'
+require 'time'
+
+include Rgraphum
+p start_time = Time.now
+
+graph = Graph.new
+after_graph = graph.simulate("BAModel",:round =>100 )
+after_graph.dump_to("./examples/ba_model/test.rgraphum")
+
+p Time.now - start_time
+
+file = File.open( File.dirname(__FILE__) + "/test.gexf", "w+" )
+file.write( after_graph.to_gephi )
+

data/examples/basic/check_modularity.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../../lib/rgraphum'
+
+#  1 - 2 
+#  #   \ /
+#  #    3
+#  #   / \
+#  #  4 - 5
+#   
+
+graph = Rgraphum::Graph.new
+graph.vertices = [{id:1,label:"A"},
+               {id:2,label:"B"},
+               {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}] # !> assigned but unused variable - i
+
+p graph.modularity # => 0.1111111111111111

data/examples/basic/make_graph.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../../lib/rgraphum'
+
+graph = Rgraphum::Graph.new()
+graph.vertices = [ {id:1,label:"1"},{id:2,label:"2"},{id:3,label:"3"} ]
+graph.edges = [ {id:1,source:1,target:2,weight:1},{id:2,source:2,target:3,weight:1},{id:3,source:3,target:1,weight:1}]
+json = graph.to_miserables
+file = File.open(  "public/miserables.js", "w+" )
+file.write(json)
+

data/examples/parser/dot.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../../lib/rgraphum'
+
+include Rgraphum
+
+graph = Rgraphum::Graph.new
+
+# add vertices
+graph.vertices << {id:1,name:"marko", age:29            }
+graph.vertices << {id:2,name:"vadas", age:27            }
+graph.vertices << {id:3,name:"lop",          lang:"java"}
+graph.vertices << {id:4,name:"josh",  age:32            }
+graph.vertices << {id:5,name:"ripple",       lang:"java"}
+graph.vertices << {id:6,name:"peter", age:35}
+
+# add vertices
+graph.edges << {id:7, label:"knows",  weight:0.5,source:1,target:2}
+graph.edges << {id:8, label:"knows",  weight:1.0,source:1,target:4}
+graph.edges << {id:9, label:"created",weight:0.4,source:1,target:3}
+graph.edges << {id:10,label:"created",weight:1.0,source:4,target:5}
+graph.edges << {id:11,label:"created",weight:0.4,source:4,target:3}
+
+#graph.to_graphviz
+p Rgraphum::Parsers::GraphvizParser.new.export(graph, File.dirname(__FILE__) + "/hoge","jpg")
+
+

data/examples/sis_model/lifegame.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative '../../lib/rgraphum'
+require 'optparse'
+
+module RgraphumSisLifeGame
+  include Rgraphum
+
+  def self.run(argv)
+    options = build_options(argv)
+    periods  = options.delete(:periods)
+    row_size = options.delete(:row_size)
+    col_size = options.delete(:col_size)
+    interval = options.delete(:interval)
+
+    sis = Simulator::SISModel.new(options)
+
+    puts "Row Size: #{row_size}"
+    puts "Col Size: #{col_size}"
+    puts "Infection rate: #{options[:infection_rate]}"
+    puts "Recovery  rate: #{options[:recovery_rate]}"
+
+    sis.simulate(periods: periods) do |period, sis|
+      puts_sis_grid_graph sis, period, periods, row_size, col_size
+      sleep interval
+      reset_cursor row_size unless periods == period
+    end
+  end
+
+  def self.build_options(argv)
+    row_size, col_size = 9, 9
+    periods = 10
+    infection_rate = 0.2 # S -> I
+    recovery_rate  = 0.3 # I -> S
+    t_per_period   = 1
+    si_pattern = nil
+    interval = 1
+
+    argv.clone.options do |opts|
+      script_name = File.basename($0)
+      opts.banner = "Usage: #{script_name} [options]"
+
+      opts.separator ""
+
+      opts.on("--size=SIZExSIZE",  'Row x Col size ex) 9x9') { |v| row_size, col_size = v.split("x").map(&:to_i) }
+      opts.on("--periods=Periods", 'Periods',  Integer) { |v| periods  = v.to_i }
+      opts.on("--infection-rate=RATE", 'Infection rate', Float) { |v| infection_rate = v.to_f }
+      opts.on("--recovery-rate=RATE",  'Recovery rate',  Float) { |v| recovery_rate  = v.to_f }
+      opts.on("--si-pattern=PATTERN",  'Pattern string line like "SISIS" or "isis"') { |v| si_pattern  = v }
+      opts.on("--interval=SECONDS",    'Animation interval in [S]: default 1.0', Float) { |v| interval  = v.to_f }
+
+      opts.separator ""
+
+      opts.separator "ex)"
+      opts.separator "  ./examples/sis_model/lifegame.rb --size=50x100 --periods=1000 --interval=0.2 --si-pattern=ssiiiss"
+      opts.separator ""
+
+      opts.on("-h", "--help", "Show this help message.") { $stdout.puts opts; exit }
+
+      opts.parse!
+    end
+
+    graph = build_grid_graph(row_size, col_size)
+
+    if si_pattern
+      si_pattern = si_pattern.downcase.split(//).map(&:to_sym)
+      k = 0
+      si_map = row_size.times.map do |i|
+        col_size.times.map do |j|
+          si = si_pattern[k]
+          k = (k + 1) % si_pattern.size
+          si
+        end
+      end
+    else
+      si_map = row_size.times.map do |i|
+        col_size.times.map do |j|
+          if i.even?
+            j.even? ? :s : :i
+          else
+            j.even? ? :i : :s
+          end
+        end
+      end
+    end
+    si_map.flatten!
+
+    {
+      graph: graph,
+      si_map: si_map,
+      infection_rate: infection_rate, # S -> I
+      recovery_rate:  recovery_rate,  # I -> S
+      t_per_period:   t_per_period,
+
+      row_size: row_size,
+      col_size: col_size,
+      periods:  periods,
+      interval: interval,
+    }
+  end
+
+  def self.build_grid_graph(row_size, col_size)
+    graph = Graph.new
+
+    row_size.times do |i|
+      col_size.times do |j|
+        graph.vertices.build(label: "#{i}-#{j}")
+      end
+    end
+
+    row_size.times do |i|
+      (1...col_size).each do |j|
+        source_vertex = graph.vertices[i * col_size + j - 1]
+        target_vertex = graph.vertices[i * col_size + j]
+        graph.edges.build(source: source_vertex, target: target_vertex)
+      end
+    end
+
+    (1...row_size).each do |i|
+      col_size.times do |j|
+        source_vertex = graph.vertices[(i - 1) * col_size + j]
+        target_vertex = graph.vertices[(i)     * col_size + j]
+        graph.edges.build(source: source_vertex, target: target_vertex)
+      end
+    end
+
+    graph
+  end
+
+  def self.reset_cursor(row_size)
+    magic_str = "\r"
+    (row_size+2).times do
+      magic_str += "\e[1A"
+    end
+    print magic_str
+  end
+
+  def self.puts_sis_grid_graph(sis, period, periods, row_size, col_size)
+    si_map = sis.si_map
+
+    puts " Priod: %4d/%4d ----------------------         " % [period, periods]
+    row_size.times do |i|
+      line = "  "
+      col_size.times do |j|
+        si = si_map[i * col_size + j]
+        case si
+        when :i
+          line += "\e[31mI"
+        when :s
+          line += "\e[32mS"
+        end
+        line += "\e[0m "
+      end
+      puts line
+    end
+    puts "----------------------------------------"
+  end
+end
+
+RgraphumSisLifeGame.run(ARGV)

data/lib/rgraphum/analyzer/linear_regression.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+# LinearRegression
+# resolve with least squares method.
+# ex. x = [1,2,3], y = [5,7,9]
+#     y = ax + b 
+#     a = 2, b = 3
+# @param [Array] x_array x paramaters
+# @param [Array] y_array y paramaters
+# @return [Array] a,b
+class Rgraphum::Analyzer::LinearRegression
+  def analyze(x_array, y_array, degree=1, round=5)
+
+     n      = x_array.size
+     x_sum  = 0.0 
+     y_sum  = 0.0 
+     xy_sum = 0.0
+     x2_sum = 0.0
+     [x_array,y_array].transpose.each do |x,y|
+       x_sum  += x
+       y_sum  += y
+       x2_sum += x**2
+       xy_sum += x*y
+     end
+
+     a = ( n * xy_sum - x_sum * y_sum) / ( n * x2_sum - x_sum**2 )
+     b = ( x2_sum * y_sum - xy_sum * x_sum ) / ( n * x2_sum - x_sum**2)
+
+     [a.round(round),b.round(round)]
+  end
+end