dither 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c63e06dd14ae60b7f896ba8b994342685a5a118f
-  data.tar.gz: 2301ba688f8160c579591c15c8230ee27ec5e803
+  metadata.gz: ddb46b01324c8b26f43cfecca3e4685eb49108d4
+  data.tar.gz: 08c81cf35fbf9eaf3633462e024f9c9f6852803d
 SHA512:
-  metadata.gz: 991fd2981ad978594df9116deb0cc51ade974a2f34c5b62d2a470688e82bf7f3eae8697a3e877d24b248bc0aabf40e41207f69be41b74609a8b734210ed668e1
-  data.tar.gz: d599badafa4375dd11f9fe120c720a44d4d997abec9f8e1ecdea352d6db557e2bf819eed1a06ffe6ea1301aad86c64b39eff3ee8e0aec9b0b5362aa16cce74fb
+  metadata.gz: 14585282cf173b2f0a7e6fefe2beedfef2c45dedfb927d0241b1dcb24dc7f8d6db9d72fd9d4dbc23dd9cb96e78fe565f741fd49086231da6a575d06e08f3bb9f
+  data.tar.gz: 0d5dd1636473a8cf8bdd0381ebdf7823322e58eac0b2cca21640ac0f432965fa9d2d56e40b828d34135830639b7529b2b00af323dbdb021d103b24ce4070bed0

data/README.md

@@ -98,6 +98,52 @@ raw_graph = {
 Dither.all_edges(raw_graph)
 ```
 
+Random walk on a graph.  Each edge has equal weight.
+```ruby
+raw_graph = {
+      :origin => 0,
+      :edges => [
+        {
+          :name => :a,
+          :src_vertex => 0,
+          :dst_vertex => 1,
+        },
+        {
+          :name => :b,
+          :src_vertex => 0,
+          :dst_vertex => 2,
+        },
+        {
+          :name => :c,
+          :src_vertex => 1,
+          :dst_vertex => 2,
+        },
+        {
+          :name => :d,
+          :src_vertex => 1,
+          :dst_vertex => 3,
+        },
+        {
+          :name => :e,
+          :src_vertex => 2,
+          :dst_vertex => 3,
+        },
+        {
+          :name => :f,
+          :src_vertex => 3,
+          :dst_vertex => 0,
+        }
+      ]
+    }
+
+graph = Dither::Graph.create(raw_graph)
+
+# infinite sequence of random walks
+graph.each do |path|
+  puts path.map(&:name).to_s
+end
+```
+
 
 # Note on Patches/Pull Requests
 

data/lib/dither/graph.rb

@@ -0,0 +1,102 @@
+
+module Dither
+  class Graph
+    include Enumerable
+
+    attr_accessor :rand, :max_depth, :origin_name
+    attr_reader :vertices, :edges, :stop_conditions, :skip_conditions
+    Edge = Struct.new(:name, :src_vertex, :dst_vertex, :count)
+    Vertex = Struct.new(:name, :edges, :count)
+
+    def initialize
+      @vertices = {}
+      @edges = []
+      @stop_conditions = []
+      @skip_conditions = []
+      @rand = Random.new
+      @max_depth = 10
+			@origin_name = :origin
+    end
+
+    def self.create(hash)
+      edges = hash[:edges]
+      graph = Graph.new
+			graph.origin_name = hash[:origin] if hash.has_key?(:origin)
+
+      edges.each do |edge|
+        graph.add_edge(edge[:name], edge[:src_vertex], edge[:dst_vertex])
+      end
+      graph
+    end
+
+    def add_edge(name, src_vertex_name, dst_vertex_name)
+      # check & create vertexes if they do not exist
+      vertices[src_vertex_name] ||= Vertex.new(src_vertex_name, [], 0)
+      vertices[dst_vertex_name] ||= Vertex.new(dst_vertex_name, [], 0)
+
+      # add edge to src_vertex
+      src_vertex = vertices[src_vertex_name]
+      dst_vertex = vertices[dst_vertex_name]
+      edge = Edge.new(name, src_vertex, dst_vertex, 0)
+      src_vertex.edges << edge
+      edges << edge
+
+      self
+    end
+
+    def add_skip_condition(cond)
+      raise Dither::Error, "#{cond} does not respond to skip?" unless cond.respond_to? :skip?
+      skip_conditions << cond
+    end
+
+    def add_stop_condition(cond)
+      raise Dither::Error, "#{cond} does not respond to stop?" unless cond.respond_to? :stop?
+      stop_conditions << cond
+    end
+
+    def origin
+      vertices[origin_name]
+    end
+
+    def random_walk
+      current_edge = origin.edges.sample(:random => rand)
+      current_max_depth = max_depth - 1
+      loop do
+        current_edge.src_vertex.count += 1
+        current_edge.count += 1
+        yield current_edge
+        current_edge = current_edge.dst_vertex.edges.sample(:random => rand)
+        current_max_depth -= 1
+        break if current_max_depth < 0 || current_edge.src_vertex.name == origin_name
+      end
+    end
+
+    def each
+      loop do
+        break if stop?
+        path = []
+        random_walk { |a| path << a }
+        next if skip?
+        yield path
+      end
+    end
+
+    def stop?
+      stop_conditions.any? { |cond| cond.stop?(self) }
+    end
+
+    def skip?
+      skip_conditions.any? { |cond| cond.skip?(self) }
+    end
+
+    def vertices_covered
+      b = vertices.count { |a| a.count > 0 }
+      b/vertices.length.to_f
+    end
+
+    def edges_covered
+      b = edges.count { |a| a.count > 0 }
+      b/edges.length.to_f
+    end
+  end
+end

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/dither.rb

@@ -43,6 +43,7 @@ require 'dither/mipog'
 require 'dither/chinese_postman_problem'
 require 'dither/aetg'
 require 'dither/aetg_pairwise'
+require 'dither/graph'
 
 if RUBY_PLATFORM =~ /java/
   require 'java'

data/spec/dither/graph_spec.rb

@@ -0,0 +1,124 @@
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Dither::Graph do
+  let(:raw_graph) do
+    {
+      :edges => [
+        {
+          :name => :a,
+          :src_vertex => :origin,
+          :dst_vertex => 1,
+        },
+        {
+          :name => :b,
+          :src_vertex => :origin,
+          :dst_vertex => 2,
+        },
+        {
+          :name => :c,
+          :src_vertex => 1,
+          :dst_vertex => 2,
+        },
+        {
+          :name => :d,
+          :src_vertex => 1,
+          :dst_vertex => 3,
+        },
+        {
+          :name => :e,
+          :src_vertex => 2,
+          :dst_vertex => 3,
+        },
+        {
+          :name => :f,
+          :src_vertex => 3,
+          :dst_vertex => :origin,
+        }
+      ]
+    }
+  end
+
+
+  let(:raw_graph_infinite_cycle) do
+		{
+			:origin => 0,
+			:edges => [
+        {
+          :name => :a,
+          :src_vertex => 0,
+          :dst_vertex => 1,
+        },
+        {
+          :name => :b,
+          :src_vertex => 1,
+          :dst_vertex => 2,
+        },
+        {
+          :name => :c,
+          :src_vertex => 2,
+          :dst_vertex => 1,
+        },
+      ]
+    }
+  end
+
+  it 'can run random walk' do
+    graph = Dither::Graph.create(raw_graph)
+    graph.rand = Random.new 0
+    graph.each do |path|
+      first = path.map(&:name)
+      expect(first).to eql([:a, :d, :f])
+      break
+    end
+  end
+
+  it 'can skip at skip condition' do
+    graph = Dither::Graph.create(raw_graph_infinite_cycle)
+    stop_cond = 'stop_cond'
+    def stop_cond.stop?(graph)
+      @count ||= 0
+      @count += 1
+      @count > 2
+    end
+    skip_cond = double("skip_cond", :skip? => true)
+    graph.add_skip_condition(skip_cond)
+    graph.add_stop_condition(stop_cond)
+    count = 0
+    graph.each do |a|
+      count += 1
+    end
+
+    expect(count).to eql(0)
+  end
+
+  it 'can stop at stop condition' do
+    graph = Dither::Graph.create(raw_graph_infinite_cycle)
+    cond = double("stop_cond", :stop? => true)
+    graph.add_stop_condition(cond)
+    count = 0
+    graph.each { |a| count += 1 }
+
+    expect(count).to eql(0)
+  end
+
+  it 'infinite cycle terminates at max_depth' do
+    graph = Dither::Graph.create(raw_graph_infinite_cycle)
+    graph.random_walk { |a| }
+
+    edge_count = graph.edges.map(&:count).reduce(&:+)
+    expect(edge_count).to eql(graph.max_depth)
+  end
+
+  it 'raise error when invalid stop condition' do
+    graph = Dither::Graph.new
+
+    expect { graph.add_stop_condition("hi") }.to raise_error
+  end
+
+  it 'raise error when invalid skip condition' do
+    graph = Dither::Graph.new
+
+    expect { graph.add_skip_condition("hi") }.to raise_error
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-16 00:00:00.000000000 Z
+date: 2015-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -72,6 +72,7 @@ files:
 - lib/dither/aetg.rb
 - lib/dither/aetg_pairwise.rb
 - lib/dither/chinese_postman_problem.rb
+- lib/dither/graph.rb
 - lib/dither/ipog.rb
 - lib/dither/ipog_helper.rb
 - lib/dither/java_ext/dither.rb
@@ -82,6 +83,7 @@ files:
 - lib/dither/version.rb
 - spec/dither/chinese_postman_problem_spec.rb
 - spec/dither/dither_spec.rb
+- spec/dither/graph_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jesg/dither
 licenses:
@@ -110,4 +112,5 @@ summary: Collection of test generation strategies
 test_files:
 - spec/dither/chinese_postman_problem_spec.rb
 - spec/dither/dither_spec.rb
+- spec/dither/graph_spec.rb
 - spec/spec_helper.rb