random_graph 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8138e4f808a95fa20e072ed897f60c1ccf271d4
+  data.tar.gz: 7e2028969794c5fa2678be5e677d10611b10a407
+SHA512:
+  metadata.gz: ff0f7677effadc9e48d2a241bed2abc72be56a381ac7479e0af7bf3a42bf1475219af92a3f080b5a3210561a285c6bc0faff4e74ed062e041e88054ec8ad31b5
+  data.tar.gz: e16b25a0847b425df5b7248bd555dcadc1a60277779213670727acbe82949402a8e4762e4d74273aa350d23f963a507284e9ec68c4a26042436cf9185db9089c

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 fselame
+
+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,48 @@
+# RandomGraph
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'random_graph'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install random_graph
+
+## Usage
+
+Install graphviz software before running visualize!
+
+Sample usage:
+
+```ruby 
+require 'random_graph'
+  include RandomGraph
+
+  # Create a Erdos Renyi GNM graph 
+  g = Graph.erdos_renyi_gnm(10, 10)
+
+  # Generate output image
+  g.visualize
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/random_graph/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'random_graph'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/random_graph.rb

@@ -0,0 +1,7 @@
+require 'random_graph/version'
+require 'random_graph/graph'
+require 'random_graph/random_generators'
+require 'random_graph/graph_algorithms'
+# opens random graph module
+module RandomGraph
+end

data/lib/random_graph/graph.rb

@@ -0,0 +1,98 @@
+require 'random_graph/random_generators'
+require 'random_graph/graph_algorithms'
+require 'graphviz'
+
+module RandomGraph
+  # Graph class implements basic graph object and relevant instance methods
+  class Graph
+    include Enumerable
+    extend RandomGenerators
+    include GraphAlgorithms
+
+    attr_reader :size
+    attr_accessor :nodes
+    attr_accessor :viz_counter
+
+    # We will used the adjacency list representation of a graph
+    # default to size 0
+    def initialize(size = 0)
+      @viz_counter = 0
+      @size = size
+      @nodes = Array.new(size) { [] }
+    end
+
+    def visualize
+      g = GraphViz.new(:G, type: :graph)
+      real_nodes = Array.new(@size)
+      (0...@size).each { |i| real_nodes[i] = g.add_nodes("#{i}") }
+      (0...@size).each do |i|
+        @nodes[i].each do |n|
+          g.add_edges(real_nodes[i], real_nodes[n]) if i < n
+        end
+      end
+      g.output(png: "graph_#{@viz_counter}.png")
+      @viz_counter += 1
+    end
+
+    def add_node
+      new_node = []
+      @nodes << new_node
+      @size += 1
+    end
+
+    def each
+      @nodes.each { |v| yield v }
+    end
+
+    # add edge between two nodes
+    def add_edge(from, to)
+       fail ArgumentError.new('invalid node')  if from >= @size || from < 0
+       fail ArgumentError.new('invalid node')  if to >= @size || to < 0
+       unless to == from
+         @nodes[from] << to unless @nodes[from].include?(to)
+         @nodes[to] << from unless @nodes[to].include?(from)
+       end 
+    end
+
+    def remove_edge(from, to)
+      @nodes[from].delete(to) if @nodes[from].include?(to)
+      @nodes[to].delete(from) if @nodes[to].include?(from)
+    end
+
+    def degree(node)
+      @nodes[node].size
+    end
+
+    def max_degree
+      max_deg = 0
+      @nodes.each do |v|
+        max_deg = v.size if max_deg < v.size
+      end
+      max_deg
+    end
+
+    def adjacent_nodes(v)
+      @nodes[v]
+    end
+
+    # is there an edge between two nodes?
+    def edge?(from, to)
+      # check if nodes are valid?
+      invalid_nodes = from >= @size || from < 0 || to >= @size || to < 0
+      @nodes[from].include?(to) if !invalid_nodes
+    end
+
+    def edge_number
+      count = 0
+      @nodes.each do |n|
+        count += n.size
+      end
+      count / 2
+    end
+
+    def average_degree
+      2.0 * edge_number / size
+    end
+
+  end
+end

data/lib/random_graph/graph_algorithms.rb

@@ -0,0 +1,103 @@
+    # implements useful graph algorithms
+    module RandomGraph
+      module GraphAlgorithms
+
+
+        def BFS_distance(root)
+          distance = Array.new(@size)
+          distance.fill(Float::INFINITY)
+
+          queue = []
+
+          distance[root] = 0
+          queue.unshift(root)
+
+          while !queue.empty? do
+
+            current = queue.pop
+            adj = adjacent_nodes(current)
+            adj.each do |a|
+             if distance[a] == Float::INFINITY
+              distance[a] = distance[current] + 1 
+              queue.unshift(a)
+            end 
+          end 
+        end 
+        distance 
+      end 
+
+      def connected_component(root)
+        distances = BFS_distance(root)
+        adjacent = []
+        (0...distances.size).each do |i|
+          adjacent << i unless distances[i] == Float::INFINITY
+        end 
+        adjacent 
+      end 
+
+      def number_of_components
+        visited = Array.new(size)
+        visited.fill(false)
+        counter = 0
+
+        (0...size).each do |i|
+          next if visited[i] == true 
+          counter += 1 
+          comp = connected_component(i) 
+          comp.each do |reachable| 
+            visited[reachable] = true 
+          end 
+        end 
+        counter
+      end 
+
+      def worst_case_diameter
+        real_bad = number_of_components > 1 ? Float::INFINITY : 0
+        worst = 0
+        if real_bad == 0
+          (0...size).each do |i|
+           distances = BFS_distance(i)
+           worst = [distances.max, worst].max 
+         end 
+       end 
+       [worst, real_bad].max 
+     end 
+
+     def average_case_diameter
+      real_bad = number_of_components > 1 ? Float::INFINITY : 0
+      total = 0
+      if real_bad == 0
+        (0...size).each do |i|
+          distances = BFS_distance(i)
+          average = distances.inject(:+).to_f / (size - 1) 
+          total += average 
+        end 
+      end 
+      total / size 
+    end 
+
+    def clustering_coefficient 
+      total_cluster = 0
+      (0...size).each do |i|
+        neighbors = adjacent_nodes(i)
+        k = neighbors.size 
+        possible_connections = k.to_f * (k - 1) / 2 
+        actual_connections = 0
+        (0...k).each do |l|
+          (i+1...k).each do |j| 
+            actual_connections += 1 if edge?(neighbors[l], neighbors[j])
+          end 
+        end 
+        if possible_connections == 0 then clustering = 0
+        else clustering = actual_connections.to_f / possible_connections
+        end 
+        total_cluster += clustering 
+      end 
+      total_cluster / size 
+    end 
+
+
+
+
+  end 
+end

data/lib/random_graph/random_generators.rb

@@ -0,0 +1,158 @@
+module RandomGraph
+  module RandomGenerators
+    # Select a graph randomly, where all graphs with n nodes and m edges
+    # are equally likely to be selected.
+    # O(n^2) expected worst-case rumtime, assuming random numbers generated
+    # in constant time. Number of random edges probed before adding edge k
+    # is (n^2 - n)/(n^2 - n - 2k). Total expected number of probes can be
+    # express as a summation, which is upper bounded by O(n^2)
+
+    def erdos_renyi_gnm(n, m)
+      fail ArgumentError.new('must have positive number of nodes') if n < 0
+      fail ArgumentError.new('must have positive number of edges') if m < 0
+
+      possible_edges = n * (n - 1) / 2
+
+      fail ArgumentError.new('too many edges') if m > possible_edges
+
+      # create empty graph
+      g = Graph.new(n)
+      added_edges = {}
+
+      # for every edge
+      (0...m).each do |i|
+        valid_edge = false
+        from = 0
+        to = 0
+        begin
+         # select a random number, representing on of the possible edges
+         r = rand(0...n**2)
+         # mapping from random number to edges, such that all edges
+         # can be selected with equal probabilities
+         from = r / n
+         to = r % n
+
+         # Keeps adjacency matrix upper triangular by mapping equivalent
+         # r values
+         if from < to
+           temp = from
+           from = to
+           to = temp
+           r = (from * n) + to
+         end
+         # make sure edge has not been slescted, and that it is not a
+         # self loop
+         valid_edge = !added_edges.key?(r) && (from != to)
+       end until valid_edge == true
+       added_edges[r] = true
+       g.add_edge(from, to)
+     end
+     g
+   end
+
+    # Create a graph with n nodes, where all edges have a probability p
+    # of existing
+    def erdos_renyi_gnp(n, p)
+      fail ArgumentError.new('must have positive number of nodes') if n < 0
+      fail ArgumentError.new('need positive probability') if p < 0
+      fail ArgumentError.new('probability cannot be greater than 1!') if p > 1
+
+      # create empty graph
+      g = Graph.new(n)
+      (0...n**2).each do |i|
+        from = i / n
+        to = i % n
+        g.add_edge(from, to) if rand <= p && to > from
+      end
+      g
+    end
+
+    # creates a Watts–Strogatz random graph. n represents the number of nodes,
+    # k is the mean degree, and b is the beta parameter
+    def watts_strogatz(n, k, b)
+      fail ArgumentError.new('must have positive number of nodes') if n < 0
+      fail ArgumentError.new('invalid beta parameter') if b < 0 || b > 1
+      fail ArgumentError.new('invalid mean degree if') if k > n || k < Math.log10(n)
+
+      # construction of regular ring lattice
+      g = Graph.new(n)
+      (0...n).each do |i|
+        (0...n).each do |j|
+          ab = (i - j).abs
+          modded = n - 1 - (k / 2)
+          checker = ab % modded
+          g.add_edge(i, j) if 0 < checker && checker <= (k / 2)
+        end
+      end
+
+      # rewiring under beta parameter
+      (0...n).each do |i|
+        (i...n).each do |j|
+          # skip non-existent edges
+          next unless g.edge?(i, j)
+          # rewire from uniform distribution
+          if rand < b && g.degree(i) != n - 1
+            # skip is node is completely wired
+            target = 0
+            loop do
+              target = rand(0...n)
+              break if target != i && !g.edge?(i, target)
+            end
+            g.remove_edge(i, j)
+            g.add_edge(i, target)
+          end
+        end
+      end
+      g
+    end
+
+    def preferential_attachment(size)
+      fail ArgumentError.new('invalid number of nodes') if size < 2
+      g = Graph.new(2)
+      g.add_edge(0, 1)
+      total_degree = 2
+
+      (2...size).each do |i|
+        g.add_node
+        r = rand(1..total_degree)
+        j = 0
+
+        loop do
+          r -= g.degree(j)
+          break if r <= 0
+          j += 1
+        end
+        g.add_edge(i, j)
+        total_degree += 2
+      end
+      g
+    end
+
+    def random_grid(n, p)
+      fail ArgumentError.new('invalid probability') if p > 1 || p < 0
+      g = Graph.new(n**2)
+      (0...n**2).each do |i|
+        bottom = (i + n) % n**2
+        right = (i + 1)
+        right -= n if right % n == 0
+        g.add_edge(i, bottom)
+        g.add_edge(i, right)
+      end
+      (0...n**2).each do |i|
+        next if rand > p 
+        top = i - n
+        top += n**2 if top < 0
+        bottom = (i + n) % n**2
+        right = i + 1
+        right -= n if right % n == 0
+        left = i - 1
+        left += n if left == -1 || left % n == n - 1
+        g.remove_edge(i, top)
+        g.remove_edge(i, bottom)
+        g.remove_edge(i, left)
+        g.remove_edge(i, right)
+      end
+      g
+    end
+  end
+end

data/lib/random_graph/version.rb

@@ -0,0 +1,3 @@
+module RandomGraph
+  VERSION = '0.1.0'
+end

data/random_graph.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'random_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'random_graph'
+  spec.version       = RandomGraph::VERSION
+  spec.authors       = ['fselame']
+  spec.email         = ['fsel@sas.upenn.edu']
+
+  spec.summary       = 'Gem for generating random graphs'
+  spec.description   = 'This gem implements the following random 
+    network generation models: Erdos-Renyi GNM and GNP, Watts-Strogatz,
+    and preferential attachement. It also implements graph algorithms to
+    study the randomly generated graphs.'
+  spec.homepage      = 'https://github.com/fselame/random_graph'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'simplecov', '~> 0.10'
+  spec.add_runtime_dependency 'ruby-graphviz', '~> 1.2'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: random_graph
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fselame
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: "This gem implements the following random \n    network generation models:
+  Erdos-Renyi GNM and GNP, Watts-Strogatz,\n    and preferential attachement. It also
+  implements graph algorithms to\n    study the randomly generated graphs."
+email:
+- fsel@sas.upenn.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "  .png"
+- " .png"
+- ".DS_Store"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/.DS_Store
+- bin/console
+- bin/setup
+- graph_0.png
+- graph_1.png
+- lib/.DS_Store
+- lib/random_graph.rb
+- lib/random_graph/.DS_Store
+- lib/random_graph/graph.rb
+- lib/random_graph/graph_algorithms.rb
+- lib/random_graph/random_generators.rb
+- lib/random_graph/version.rb
+- random_graph.gemspec
+homepage: https://github.com/fselame/random_graph
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Gem for generating random graphs
+test_files: []