dither 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6aeec317ee301c987fa9f850ae1d131ae2e5fc6
-  data.tar.gz: 5258de5745ae92ca80c7040911e7cf0d9a8156ff
+  metadata.gz: d7fbd5b281ba90ffd541192320abf17d31c8e345
+  data.tar.gz: 08e49deed38f7d4e239f080c28341c023317d195
 SHA512:
-  metadata.gz: 771652b00d5078fcc02585ac67caa0c891081f6dd4ad75747cd08491242f8fd019030a07b4a2cfbc5154723c6dba8b54f8ab614bd043f6268b35d358a5b0068f
-  data.tar.gz: 08ab024560ddd9a7cde11f8ca7ae6ae77e69267e4478b7c6dad079ede63b626ed9b7a52d3ef0a0ab5053dc05ba6aaaa9b871c27542f804572a4482abca5ff9eb
+  metadata.gz: a4f14b7801a1914321ea7dd02dd803dab97cc7c9ad1a0fc44658093ded0deec3defba34eae97fb4b0984f9c99eef4a94ad828e88e6f4d010ce67c9d31a139726
+  data.tar.gz: fd023b9f6fd8d00ce0d776546ad807515f211283a5f8b62bf0cdc1b088ae2764d7f69773d2a6b96a5711164db3a92889bcd1eb89f9c7dc7c270e0ac88c8c4112

data/README.md

@@ -3,6 +3,7 @@ Collection of combinatorial test generation strategies.
 
 # Usage
 
+## Pairwise Testing
 ```ruby
 require 'dither'
 
@@ -31,6 +32,49 @@ Dither.ipog([[true, false],
 
 ```
 
+## Graph Models (Experimental)
+```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,
+        }
+      ]
+    }
+
+# shortest path to cover all edges at least once
+Dither.all_edges(raw_graph)
+```
+
+
 # Note on Patches/Pull Requests
 
 * Fork the project.

data/lib/dither/chinese_postman_problem.rb

@@ -0,0 +1,220 @@
+
+# implement thimbleby's solution to the chinese @postman problem
+# http://www.cs.swansea.ac.uk/~csharold/cv/files/cpp.pdf
+
+module Dither
+  module Cpp
+    class Graph
+
+      attr_accessor :n, :neg, :pos, :degree, :path, :edges, :cheapest_edge, :f, :defined, :label, :c, :initialized, :origin
+
+      Edge = Struct.new(:name, :src_vertex, :dst_vertex)
+
+      def initialize(n)
+
+        @n = n
+        @degree = Array.new(n).fill(0)
+        @defined = Array.new(n).fill { |_| Array.new(n).fill(false) }
+        @label = Array.new(n).fill { |_| Array.new(n).fill { |_| [] } }
+        @c = Array.new(n).fill { |_| Array.new(n).fill(0.0) }
+        @f = Array.new(n).fill { |_| Array.new(n).fill(0) }
+        @edges = Array.new(n).fill { |_| Array.new(n).fill(0) }
+        @cheapest_edge = Array.new(n).fill { |_| Array.new(n).fill(0) }
+        @path = Array.new(n).fill { |_| Array.new(n).fill(0) }
+        @initialized = true
+      end
+
+
+      def cpp
+        initialized?
+        least_cost_paths
+        check_valid
+        find_feasible
+        while improvments do
+        end
+        print(origin)
+      end
+
+      def self.create(raw_graph)
+        vertices = [].to_set
+        raw_graph[:edges].each do |edge|
+          vertices << edge[:src_vertex]
+          vertices << edge[:dst_vertex]
+        end
+
+        graph = Graph.new(vertices.length)
+
+        raw_graph[:edges].each do |edge|
+          graph.add_edge(edge[:name], edge[:src_vertex], edge[:dst_vertex], 1)
+        end
+        graph.origin = raw_graph[:origin]
+        graph
+      end
+
+      def add_edge(lab, u, v, cost)
+        @label[u][v] = [] unless defined[u][v]
+        @label[u][v] << lab
+        if !defined[u][v] || c[u][v] > cost
+          @c[u][v] = cost
+          @cheapest_edge[u][v] = edges[u][v]
+          @defined[u][v] = true
+          @path[u][v] = v
+        end
+        @edges[u][v] += 1
+        @degree[u] += 1
+        @degree[v] -= 1
+        self
+      end
+
+      def check_valid
+        (0...n).each do |i|
+          raise Dither::Error, 'negative cycle' if c[i][i] < 0
+          (0...n).each do |j|
+            raise Dither::Error, 'not strongly connected' unless defined[i][j]
+          end
+        end
+      end
+
+      def least_cost_paths
+        (0...n).each do |k|
+          (0...n).each do |i|
+            if defined[i][k]
+              (0...n).each do |j|
+                if defined[k][j] && (!defined[i][j] || c[i][j] > c[i][k]+c[k][j])
+                  @defined[i][j] = true
+                  @path[i][j] = path[i][k]
+                  @c[i][j] = c[i][k] + c[k][j]
+                  # negative cycle
+                  return if i == j && c[i][j] < 0
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def find_feasible
+        nn, np = 0, 0
+        (0...n).each do |i|
+          if degree[i] < 0
+            nn += 1
+          elsif degree[i] > 0
+            np += 1
+          end
+        end
+
+        @neg = Array.new(nn)
+        @pos = Array.new(np)
+        nn, np = 0, 0
+        (0...n).each do |i|
+          if degree[i] < 0
+            @neg[nn] = i
+            nn += 1
+          elsif degree[i] > 0
+            @pos[np] = i
+            np += 1
+          end
+        end
+
+        (0...nn).each do |u|
+          i = neg[u]
+          (0...np).each do |v|
+            j = pos[v]
+            @f[i][j] = -degree[i] < degree[j] ? -degree[i] : degree[j]
+            @degree[i] += f[i][j]
+            @degree[j] -= f[i][j]
+          end
+        end
+      end
+
+      def improvments
+        r = Graph.new(n)
+        (0...neg.length).each do |u|
+          i = neg[u]
+          (0...pos.length).each do |v|
+            j = pos[v]
+            if edges[i][j] > 0
+              r.add_edge(nil, i, j, c[i][j])
+            end
+            if f[i][j] != 0
+              r.add_edge(nil, j, i, -c[i][j])
+            end
+          end
+        end
+
+        r.least_cost_paths
+        (0...n).each do |i|
+          if r.c[i][i] < 0
+            k = 0
+            kunset = true
+            u = i
+            begin
+              v = r.path[u][i]
+              if r.c[u][v] < 0 && (kunset || k > f[v][u])
+                k = f[v][u]
+                kunset = false
+              end
+              u = v
+            end while u != i
+            u = i
+            begin
+              v = r.path[u][i]
+              if r.c[u][v] < 0
+                @f[v][u] -= k
+              else
+                @f[u][v] += k
+              end
+              u = v
+            end while u != i
+            return true
+          end
+        end
+        false
+      end
+
+      def print(start)
+        result = []
+        v = start
+        loop do
+          skip = false
+          u = v
+          (0...n).each do |i|
+            if f[u][i] > 0
+              v = i
+              @f[u][v] -= 1
+              while u != v
+                p = path[u][v]
+                result << Edge.new(label[u][p][cheapest_edge[u][p]], u, p)
+                u = p
+              end
+              skip = true
+            end
+          end
+
+          next if skip
+
+          v = -1
+          (0...n).each do |i|
+            if edges[u][i] > 0
+              v = i if v == -1 || i != path[u][start]
+            end
+          end
+          return result if v == -1
+          result << Edge.new(label[u][v][edges[u][v] - 1], u, v)
+          @edges[u][v] -= 1
+        end
+        result
+      end
+
+      def initialized?
+        raise Dither::Error, 'graph not initialized' unless initialized
+        raise Dither::Error, 'origin not set' unless origin
+        @initialized = false
+      end
+    end # Graph
+  end # Cpp
+
+  def self.all_edges(raw_graph)
+    Dither::Cpp::Graph.create(raw_graph).cpp
+  end
+end # Dither

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

data/lib/dither.rb

@@ -33,6 +33,7 @@ require 'dither/test_case'
 require 'dither/ipog_helper'
 require 'dither/ipog'
 require 'dither/mipog'
+require 'dither/chinese_postman_problem'
 
 if RUBY_PLATFORM =~ /java/
   require 'java'

data/spec/dither/chinese_postman_problem_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Dither::Cpp::Graph do
+  let(:raw_graph) do
+    {
+      :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,
+        }
+      ]
+    }
+  end
+
+  it 'can compute chinese postman problem' do
+    expected = [
+      [:b, 0, 2],
+      [:e, 2, 3],
+      [:f, 3, 0],
+      [:a, 0, 1],
+      [:c, 1, 2],
+      [:e, 2, 3],
+      [:f, 3, 0],
+      [:a, 0, 1],
+      [:d, 1, 3],
+      [:f, 3, 0]].map { |a| Dither::Cpp::Graph::Edge.new(*a) }
+    expect(Dither.all_edges(raw_graph)).to eq(expected)
+  end
+
+  it 'verify origin is set' do
+    raw_graph.delete(:origin)
+    expect { Dither.all_edges(raw_graph) }.to raise_error
+  end
+
+  it 'raise error when calling cpp twice' do
+    graph = Dither::Cpp::Graph.create(raw_graph)
+    graph.cpp
+    expect { graph.cpp }.to raise_error
+  end
+
+  it 'raise error when graph is not strongly connected' do
+    raw_graph[:edges] << {
+      :name => :w,
+      :src_vertex => 23,
+      :dst_vertex => 78
+    }
+
+    expect { Dither.all_edges(raw_graph) }.to raise_error
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -69,6 +69,7 @@ files:
 - Rakefile
 - dither.gemspec
 - lib/dither.rb
+- lib/dither/chinese_postman_problem.rb
 - lib/dither/ipog.rb
 - lib/dither/ipog_helper.rb
 - lib/dither/java_ext/dither.rb
@@ -77,6 +78,7 @@ files:
 - lib/dither/test_case.rb
 - lib/dither/unbound_param.rb
 - lib/dither/version.rb
+- spec/dither/chinese_postman_problem_spec.rb
 - spec/dither/dither_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jesg/dither
@@ -104,5 +106,6 @@ signing_key:
 specification_version: 4
 summary: Collection of test generation strategies
 test_files:
+- spec/dither/chinese_postman_problem_spec.rb
 - spec/dither/dither_spec.rb
 - spec/spec_helper.rb