art-decomp 0.0.0

data/lib/art-decomp/fsm.rb

@@ -0,0 +1,128 @@
+module ArtDecomp class FSM
+
+  def self.from_kiss kiss
+    kiss = File.read kiss unless kiss.index "\n"
+    inputs, outputs, state, next_state = [], [], [], []
+    kiss.lines do |line|
+      next unless line =~ /^\s*[01-]+\s+\S+\s+\S+\s+[01-]+\s*$/
+      ins, st, nxt, outs = line.split
+      inputs     << ins.split(//).map(&:to_sym)
+      outputs    << outs.split(//).map(&:to_sym)
+      state      << (st  == '*' ? DontCare : st.to_sym)
+      next_state << (nxt == '*' ? DontCare : nxt.to_sym)
+    end
+    # FIXME: the below hack makes state have all possible values by expanding a don’t-care a bit (if present)
+    (next_state - state - [DontCare]).each do |missing_state|
+      i = state.index DontCare
+      state      << missing_state
+      next_state << next_state[i]
+      inputs     << inputs[i]
+      outputs    << outputs[i]
+    end if state.index DontCare
+    new inputs.transpose, outputs.transpose, state, next_state
+  end
+
+  def initialize inputs, outputs, state, next_state
+    @inputs, @outputs, @state, @next_state = inputs.freeze, outputs.freeze, state.freeze, next_state.freeze
+  end
+
+  def == other
+    [@inputs, @outputs, @state, @next_state] == [other.inputs, other.outputs, other.state, other.next_state]
+  end
+
+  def beta_f
+    outs = @outputs.map { |output| Blanket.from_array output }
+    outs.inject(:*) * Blanket.from_array(@next_state)
+  end
+
+  def beta_q
+    Blanket.from_array @state
+  end
+
+  def beta_x ins
+    return Blanket[B[*0...@state.size]] if ins.empty?
+    ins.map { |i| Blanket.from_array @inputs[i] }.inject :*
+  end
+
+  alias eql? ==
+
+  def expand_x ins
+    return self unless ins.any? { |i| @inputs[i].include? DontCare }
+    FSM.from_kiss to_kiss.lines.map { |line| line.dc_expand(ins) }.flatten.sort.join
+  end
+
+  def fsm_cells archs
+    return 0 if @outputs.map { |output| Blanket.from_array output }.inject(:*).size < 2
+    Arch[input_count + beta_q.pins, output_count + beta_q.pins].cells archs
+  end
+
+  def hash
+    @inputs.hash ^ @outputs.hash ^ @state.hash ^ @next_state.hash
+  end
+
+  def implementable_in? archs
+    return true if @outputs.map { |output| Blanket.from_array output }.inject(:*).size < 2
+    input_count + beta_q.pins <= archs.map(&:pins).max
+  end
+
+  def input_count
+    @inputs.size
+  end
+
+  def input_relevance
+    seps = beta_f.seps
+    perpin = (beta_q.seps & seps).size.to_f / beta_q.pins
+    more, less = (0...input_count).map { |i| [(beta_x(Set[i]).seps & seps).size, i] }.sort.reverse.reject { |rel, i| rel.zero? }.partition { |rel, i| rel > perpin }
+    more.map(&:last) + [nil] * beta_q.pins + less.map(&:last)
+  end
+
+  def q_encoding rows
+    # FIXME: consider tr DontCare, '*'
+    encoding @state, rows
+  end
+
+  def output_count
+    @outputs.size
+  end
+
+  def state_rows_of_next_state_of rows
+    state = @next_state[rows.bits.first]
+    B[*(0...@state.size).select { |i| @state[i] == state or @state[i] == DontCare }]
+  end
+
+  def stats
+    "#{@inputs.size}/#{@outputs.size}+#{(@state.uniq - [DontCare]).size}s"
+  end
+
+  def to_kiss
+    st   = @state.map      { |e| e == DontCare ? '*' : e }
+    nxt  = @next_state.map { |e| e == DontCare ? '*' : e }
+    div  = Array.new @state.size, ' '
+    cols = @inputs + [div, st, div, nxt, div] + @outputs
+    KISS.new(cols.transpose.map(&:join)).formatted
+  end
+
+  def x_encoding ins, rows
+    ins.map { |i| encoding @inputs[i], rows }.join
+  end
+
+  def y_encoding rows
+    @outputs.map { |output| encoding output, rows }.join
+  end
+
+  protected
+
+  attr_reader :inputs, :outputs, :state, :next_state
+
+  private
+
+  def encoding column, rows
+    encs = rows.bits.map { |row| column[row] }.uniq - [DontCare]
+    case encs.size
+    when 0 then DontCare.to_s
+    when 1 then encs.first.to_s
+    else raise AmbiguousEncodingQuery, "ambiguous encoding query: block #{rows.bits.join ','}"
+    end
+  end
+
+end end

data/lib/art-decomp/graph.rb

@@ -0,0 +1,78 @@
+module ArtDecomp class Graph
+
+  attr_reader :edges, :vertices
+
+  def initialize blanket, seps
+    @vertices = blanket.ints.dup
+    @vertices.delete_if { |this| @vertices.any? { |other| other != this and other & this == this } }
+    @edges    = Set[]
+    seps.each do |sep|
+      @vertices.pairs.each do |a, b|
+        @edges << Set[a,b] unless (a & sep).zero? or (b & sep).zero? or (a | b) & sep != sep
+      end
+    end
+  end
+
+  def adjacent *vertices
+    return Set[] if @edges.all? { |edge| (edge & vertices).empty? }
+    @edges.reject { |edge| (edge & vertices).empty? }.inject(:|) - vertices
+  end
+
+  def blanket_from_colouring
+    colours = {}
+    @vertices.sort_by { |vert| [-degree(vert), vert] }.each do |vertex|
+      forbidden = adjacent(vertex).map { |vert| colours[vert] }.to_set
+      # FIXME: consider selecting colours on the least-popular-first basis
+      colour = :a
+      colour = colour.next while forbidden.include? colour
+      colours[vertex] = colour
+    end
+    blocks = Hash.new 0
+    colours.each { |vertex, colour| blocks[colour] |= vertex }
+    Blanket.new blocks.values
+  end
+
+  def complete?
+    2 * @edges.size == @vertices.size * (@vertices.size - 1)
+  end
+
+  def degree vertex
+    @edges.count { |edge| edge.include? vertex }
+  end
+
+  def merge_by_edge_labels!
+    return self if @vertices.size == 1
+    pins = @vertices.size.log2_ceil
+    until @vertices.size.log2_ceil < pins
+      # FIXME: edge labels can/should be cached from previous computations
+      a, b = *@edges.sort_by { |edge| yield *edge }.first
+      merge! a, b
+    end
+    self
+  end
+
+  def merge_by_vertex_degrees!
+    pins = @vertices.size.log2_ceil
+    until @vertices.size.log2_ceil < pins or complete?
+      a, b = *@vertices.sort_by { |v| -degree(v) }.pairs.find { |v1, v2| not @edges.include? Set[v1, v2] }
+      merge! a, b
+    end
+    self
+  end
+
+  def merge_until_complete!
+    merge_by_vertex_degrees! until complete?
+    self
+  end
+
+  private
+
+  def merge! a, b
+    new_edges = adjacent(a, b).map { |vert| Set[a|b, vert] }
+    @vertices.subtract [a, b]
+    @vertices.add a|b
+    @edges.delete_if { |edge| edge.include? a or edge.include? b }
+    @edges.merge new_edges
+  end
+
+end end

data/lib/art-decomp/kiss.rb

@@ -0,0 +1,47 @@
+module ArtDecomp class KISS
+
+  def initialize lines
+    @lines = lines
+  end
+
+  def formatted
+    @lines.sort!
+    @lines.uniq!
+    drop_overlapping
+    combine_matching
+    @lines.join("\n") + "\n"
+  end
+
+  private
+
+  def combine_matching
+    a, b, i = find_matching
+    while a and b and i
+      @lines.delete a
+      @lines.delete b
+      @lines << a[0...i] + DontCare.to_s + a[i+1..-1]
+      a, b, i = find_matching
+    end
+    @lines.sort!
+  end
+
+  def drop_overlapping
+    @lines.reject! do |line|
+      @lines.any? { |l| line != l and line[/\s.*$/] == l[/\s.*$/] and line =~ Regexp.new("^#{l.split.first.tr DontCare.to_s, '.'}\s") }
+    end
+  end
+
+  def find_matching
+    @lines.pairs.each do |a, b|
+      if a[/\s.*$/] == b[/\s.*$/]
+        a.size.times do |i|
+          if a[0...i] == b[0...i] and a[i+1..-1] == b[i+1..-1]
+            return a, b, i
+          end
+        end
+      end
+    end
+    nil
+  end
+
+end end

data/lib/art-decomp/logging.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require 'gazer'
+require 'logger'
+
+module ArtDecomp class Logging < Gazer::Aspect::Base
+
+  def self.level
+    @@log.level
+  end
+
+  def self.level= level
+    @@log.level = level
+  end
+
+  def self.log= log
+    @@log = Logger.new log
+    @@log.level = Logger::INFO
+    @@log.formatter = proc { |sev, date, name, msg| "#{date} #{msg}\n" }
+    @@indent = ''
+    apply!
+  end
+
+  def self.off
+    # FIXME: if instances can be unadvised, do that and close @@log
+    @@log = Logger.new '/dev/null'
+  end
+
+  after instances_of(Executable) => :run do |point|
+    @@log.info "final best decomposition: #{point.object.best} cells"
+  end
+
+  before instances_of(Executable) => :decompositions do |point|
+    @@indent = '  ' * (point.object.iters - point.args[1])
+    path     = point.args[2][point.object.dir.size+1..-1]
+    archs    = point.object.archs.map(&:to_s).sort.reverse.join '+'
+    @@log.info "#{@@indent}FSM #{point.args[0].stats} → #{archs} (#{path}) with #{point.object.gens} – best so far: #{point.object.best} cells"
+  end
+
+  before instances_of(UVGenerator.constants.map { |c| eval("UVGenerator::#{c}") }) => :uv_pairs do |point|
+    @@log.info "#{@@indent}  UV with #{point.object.class.to_s.split('::').last}"
+  end
+
+  before instances_of(QuGenerator.constants.map { |c| eval("QuGenerator::#{c}") }) => :blankets do |point|
+    @@log.info "#{@@indent}    U = #{point.args[1].sort.inspect}, V = #{point.args[2].sort.inspect}, Qu with #{point.object.class.to_s.split('::').last}"
+  end
+
+  before instances_of(QvGenerator.constants.map { |c| eval("QvGenerator::#{c}") }) => :blankets do |point|
+    @@log.debug "#{@@indent}      |Qu| = #{point.args[3].size}, Qv+G with #{point.object.class.to_s.split('::').last}"
+  end
+
+end end

data/lib/art-decomp/qu_generator/block_table.rb

@@ -0,0 +1,42 @@
+module ArtDecomp class QuGenerator::BlockTable
+
+  def blankets fsm, u, v
+    Enumerator.new do |yielder|
+      @seps   = fsm.beta_f.seps
+      @rows   = fsm.beta_q.ints.dup
+      @cols   = fsm.beta_x(u).ints
+      @r_adms = {}
+      fold_matching!
+      yielder.yield Blanket.new @rows
+      while @rows.size > 1
+        fold!
+        yielder.yield Blanket.new @rows
+      end
+    end
+  end
+
+  private
+
+  def fold!
+    pins = @rows.size.log2_ceil
+    until @rows.size.log2_ceil < pins
+      @rows.pairs.each do |a, b|
+        @r_adms[Set[a, b]] ||= @cols.map { |col| @seps.r_adm((a | b) & col) }.max
+      end
+      a, b = *@r_adms.min_by { |key, val| val }.first
+      @r_adms.delete_if { |key, val| key.include? a or key.include? b }
+      @rows.subtract [a, b]
+      @rows.add a|b
+    end
+  end
+
+  def fold_matching!
+    loop do
+      a, b = *@rows.pairs.find { |r1, r2| @cols.all? { |col| (r1 & col).zero? or (r2 & col).zero? } }
+      break unless a and b
+      @rows.subtract [a, b]
+      @rows.add a|b
+    end
+  end
+
+end end

data/lib/art-decomp/qu_generator/edge_labels.rb

@@ -0,0 +1,24 @@
+module ArtDecomp class QuGenerator::EdgeLabels
+
+  def blankets fsm, u, v
+    Enumerator.new do |yielder|
+      seps = fsm.beta_f.seps - fsm.beta_x(u).seps
+      @graph = Graph.new fsm.beta_q, seps
+      initial_merge
+      yielder.yield Blanket.new @graph.vertices
+      while @graph.vertices.size > 1
+        @graph.merge_by_edge_labels! do |a, b|
+          [seps.r_adm(a|b), (Blanket[a,b].seps & seps).size]
+        end
+        yielder.yield Blanket.new @graph.vertices
+      end
+    end
+  end
+
+  private
+
+  def initial_merge
+    @graph.merge_until_complete!
+  end
+
+end end

data/lib/art-decomp/qv_generator/bipainting.rb

@@ -0,0 +1,12 @@
+module ArtDecomp class QvGenerator::Bipainting
+
+  def blankets fsm, u, v, beta_qu
+    Enumerator.new do |yielder|
+      beta_u = fsm.beta_x u
+      beta_v = fsm.beta_x v
+      bipainter = Bipainter.new fsm.beta_q, beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps
+      yielder.yield bipainter.blankets
+    end
+  end
+
+end end

data/lib/art-decomp/qv_generator/graph_colouring.rb

@@ -0,0 +1,16 @@
+module ArtDecomp class QvGenerator::GraphColouring
+
+  def blankets fsm, u, v, beta_qu
+    Enumerator.new do |yielder|
+      beta_u  = fsm.beta_x u
+      beta_v  = fsm.beta_x v
+      beta_g  = Graph.new(fsm.beta_q * beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps).blanket_from_colouring
+      beta_qv = Graph.new(fsm.beta_q, beta_g.seps - beta_v.seps).blanket_from_colouring
+      yielder.yield beta_qv, beta_g
+      beta_qv = Graph.new(fsm.beta_q, fsm.beta_f.seps - beta_u.seps - beta_qu.seps - beta_v.seps).blanket_from_colouring
+      beta_g  = Graph.new(beta_qv * beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps).blanket_from_colouring
+      yielder.yield beta_qv, beta_g
+    end
+  end
+
+end end

data/lib/art-decomp/qv_generator/graph_merging.rb

@@ -0,0 +1,19 @@
+module ArtDecomp class QvGenerator::GraphMerging
+
+  def blankets fsm, u, v, beta_qu
+    Enumerator.new do |yielder|
+      beta_u = fsm.beta_x u
+      beta_v = fsm.beta_x v
+      qv_graph = Graph.new fsm.beta_q, fsm.beta_f.seps - beta_u.seps - beta_qu.seps - beta_v.seps
+      loop do
+        beta_qv = Blanket.new qv_graph.vertices
+        g_graph = Graph.new beta_qv * beta_v, fsm.beta_f.seps - beta_u.seps - beta_qu.seps
+        beta_g = Blanket.new g_graph.merge_until_complete!.vertices
+        yielder.yield [beta_qv, beta_g]
+        break if qv_graph.complete?
+        qv_graph.merge_by_vertex_degrees!
+      end
+    end
+  end
+
+end end

data/lib/art-decomp/sep.rb

@@ -0,0 +1,7 @@
+module ArtDecomp class Sep
+
+  def self.[] first, last
+    1 << first | 1 << last
+  end
+
+end end

data/lib/art-decomp/uv_generator/braindead.rb

@@ -0,0 +1,22 @@
+module ArtDecomp class UVGenerator::Braindead
+
+  def initialize fsm, archs
+    @fsm         = fsm
+    @input_count = fsm.input_count
+    @max_v_size  = archs.map(&:pins).max
+  end
+
+  def uv_pairs
+    Enumerator.new do |yielder|
+      inputs = (0...@input_count).to_a
+      (0...2**@input_count).each do |vector|
+        u, v = Set[], Set[]
+        @input_count.times do |bit|
+          (vector[bit].zero? ? u : v) << inputs[bit]
+        end
+        yielder.yield @fsm.expand_x(v), u, v if v.size <= @max_v_size
+      end
+    end
+  end
+
+end end

data/lib/art-decomp/uv_generator/relevance.rb

@@ -0,0 +1,23 @@
+module ArtDecomp class UVGenerator::Relevance
+
+  def initialize fsm, archs
+    @fsm         = fsm
+    @relevance   = fsm.input_relevance.reverse
+    @max_v_sizes = archs.map(&:pins).to_set
+  end
+
+  def uv_pairs
+    @cache = Set[]
+    Enumerator.new do |yielder|
+      (0...2**@relevance.size).each do |vector|
+        bits = vector.bits
+        next unless @max_v_sizes.include? bits.size
+        v = @relevance.values_at(*bits).compact.to_set
+        u = (@relevance - v.to_a).compact.to_set
+        yielder.yield @fsm.expand_x(v), u, v unless @cache.include? v
+        @cache << v
+      end
+    end
+  end
+
+end end

data/lib/art-decomp.rb

@@ -0,0 +1,65 @@
+if RUBY_VERSION < '1.9'
+
+  require 'backports/1.9'
+
+  class Array
+    def keys
+      map &:first
+    end
+    def values
+      map &:last
+    end
+  end
+
+  def Dir.exists? dir
+    File.exists? dir and File.directory? dir
+  end
+
+end
+
+
+
+module ArtDecomp
+
+  DontCare = :-
+
+  module QuGenerator
+  end
+
+  module QvGenerator
+  end
+
+  module UVGenerator
+  end
+
+end
+
+
+
+require 'set'
+
+require_relative 'core/enumerable'
+require_relative 'core/file'
+require_relative 'core/integer'
+require_relative 'core/set'
+require_relative 'core/string'
+
+require_relative 'art-decomp/arch'
+require_relative 'art-decomp/b'
+require_relative 'art-decomp/bipainter'
+require_relative 'art-decomp/blanket'
+require_relative 'art-decomp/decomposer'
+require_relative 'art-decomp/decomposition'
+require_relative 'art-decomp/exceptions'
+require_relative 'art-decomp/executable'
+require_relative 'art-decomp/fsm'
+require_relative 'art-decomp/graph'
+require_relative 'art-decomp/kiss'
+require_relative 'art-decomp/qu_generator/block_table'
+require_relative 'art-decomp/qu_generator/edge_labels'
+require_relative 'art-decomp/qv_generator/bipainting'
+require_relative 'art-decomp/qv_generator/graph_colouring'
+require_relative 'art-decomp/qv_generator/graph_merging'
+require_relative 'art-decomp/sep'
+require_relative 'art-decomp/uv_generator/braindead'
+require_relative 'art-decomp/uv_generator/relevance'

data/lib/core/enumerable.rb

@@ -0,0 +1,24 @@
+module Enumerable
+
+  def self.all_combinations source
+    result_count = source.map(&:size).inject :*
+    group_count = 1
+    result = []
+    source.each do |elems|
+      row = []
+      group_count.times do
+        elems.each do |elem|
+          (result_count / group_count / elems.size).times { row << elem }
+        end
+      end
+      group_count *= elems.size
+      result << row
+    end
+    result.transpose
+  end
+
+  def pairs
+    respond_to?(:combination) ? combination(2) : to_a.combination(2)
+  end
+
+end

data/lib/core/file.rb

@@ -0,0 +1,11 @@
+class File
+
+  def self.dump_object object, path
+    write_data Marshal.dump(object), path
+  end
+
+  def self.write_data data, path
+    self.open(path, 'w') { |f| f << data }
+  end
+
+end

data/lib/core/integer.rb

@@ -0,0 +1,13 @@
+class Integer
+
+  # FIXME: consider right-shifting self and counting ones
+  def bits
+    (0...to_s(2).size).select { |bit| self[bit] == 1 }
+  end
+
+  def log2_ceil
+    return 0 if self == 0 or self == 1
+    (self - 1).to_s(2).size
+  end
+
+end

data/lib/core/set.rb

@@ -0,0 +1,16 @@
+class Set
+
+  def r_adm int
+    # FIXME: consider an algorithm with lesser complexity
+    seps = select { |sep| int & sep == sep }
+    subblocks = Set[]
+    int.bits.each do |elem|
+      bit = 1 << elem
+      subblock = subblocks.find { |sb| seps.none? { |sep| (sb | bit) & sep == sep } } || 0
+      subblocks.delete subblock
+      subblocks << (subblock | bit)
+    end
+    subblocks.size.log2_ceil
+  end
+
+end

data/lib/core/string.rb

@@ -0,0 +1,13 @@
+class String
+
+  def dc_expand columns = 0...size
+    return [self] unless include? ArtDecomp::DontCare.to_s
+    offsets = columns.sort
+    i = index ArtDecomp::DontCare.to_s, offsets.shift until columns.include? i or offsets.empty?
+    return [self] unless columns.include? i
+    zero,    one    = dup, dup
+    zero[i], one[i] = '0', '1'
+    [zero.dc_expand(columns), one.dc_expand(columns)].flatten
+  end
+
+end

data/spec/art-decomp/arch_spec.rb

@@ -0,0 +1,23 @@
+module ArtDecomp describe Arch do
+
+  it 'should be instantiable Array-style (and compare and hash properly)' do
+    Arch[5,1].should == Arch.new(5, 1)
+    Arch[5,2].should_not == Arch[5,1]
+    Arch[4,1].should_not == Arch[5,1]
+    Arch[5,1].hash.should == Arch[5,1].hash
+    Arch[5,1].should eql Arch[5,1]
+  end
+
+  it 'should have a common String representation' do
+    Arch[5,1].to_s.should == '5/1'
+    Arch[4,2].to_s.should == '4/2'
+  end
+
+  it 'should report how many cells of given Archs it requires' do
+    Arch[4,3].cells(Set[Arch[4,2], Arch[5,1]]).should == 2
+    Arch[4,3].cells(Set[Arch[5,1]]).should            == 3
+    Arch[5,3].cells(Set[Arch[4,3]]).should be_nil
+    Arch[5,3].cells(Set[Arch[5,2]]).should            == 2
+  end
+
+end end

data/spec/art-decomp/b_spec.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+module ArtDecomp describe B do
+
+  context 'when representing ‘set bits’ concept' do
+
+    it 'should provide proper representation (also across the Fixnum/Bignum boundary)' do
+      B[].should     == 0b0
+      B[0].should    == 0b1
+      B[5,8].should  == 0b100100000
+      B[30].should   == 2**30
+      B[40].should   == 2**40
+      B[1,69].should == 2**69 + 0b10
+    end
+
+    it 'should uniformly work inside Sets (also across the Fixnum/Bignum boundary)' do
+      B[].hash.should     == 0b0.hash
+      B[0].hash.should    == 0b1.hash
+      B[5,8].hash.should  == 0b100100000.hash
+      B[30].hash.should   == (2**30).hash
+      B[40].hash.should   == (2**40).hash
+      B[1,69].hash.should == (2**69 + 0b10).hash
+    end
+
+  end
+
+end end