dither 0.0.10-java → 0.0.11-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f604e88d5d8eac1f835c1dda247b4fd0772002ea
-  data.tar.gz: 4dbd069d8a778df29828151bbb176093885f0f3b
+  metadata.gz: 3e5528867e133a68bb9a429ae778153f59d7fa07
+  data.tar.gz: 06470e7386b123b3a6642fb48761318ad9bfc0be
 SHA512:
-  metadata.gz: b648cc3b440e1f2cd88dd47d85cd84e31a6755fe5c6912b11aa23c1fa405155c55a25a74f80e37b37a91ec5fe40e62abb74adba574eb87d86abe4968521adfd2
-  data.tar.gz: 20ef90a73de9b0f31bc43f3435c33f5202b1eef2aa8ecc7971eb42900dde8b4a1f243ff1dba5ede919cf5555a0f2e4d114bf5011d3793f15b845fa6df0273b08
+  metadata.gz: 70072c1bcfe0006bb632bf33542e700c8dd1036c2946b3d8bed6f4f752d1feffdbbf850a45eae283ab0651019c10b4ca03551f72741a6e9fe8dd8ae90b210741
+  data.tar.gz: 630cc4a6cef209358550c04242a82093ddf7729de981ccd3eeb942b8b144286da4c20a4bebe31c07dc2fada801b21e2327fd8b8f59d8b881ac59e097cba0ab9c

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: java
 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
@@ -70,6 +70,7 @@ files:
 - dither.gemspec
 - lib/dither.jar
 - lib/dither.rb
+- lib/dither/chinese_postman_problem.rb
 - lib/dither/ipog.rb
 - lib/dither/ipog_helper.rb
 - lib/dither/java_ext/dither.rb
@@ -78,6 +79,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
@@ -100,10 +102,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: dither
-rubygems_version: 2.4.5
+rubygems_version: 2.4.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