quine_mc 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/Rakefile

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

data/bin/quine_mc

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'quine_mc'
+
+puts "Welcome.  This is Erik Formella's Quine McClusky Logic Minimizer."
+puts
+puts "Eneter the minterms of your function.  Exclude dont cares"
+
+minterms = gets.chomp
+m_a = minterms.scan(/\d+/).map {|x| x.to_i}
+
+puts "Now enter the don't cares please"
+dont_cares = gets.chomp
+dc_a = dont_cares.scan(/\d+/).map {|x| x.to_i}
+
+solution = QuineMc::Quine_McClusky.new(m_a, dc_a)
+puts
+puts
+puts "The solution for:"
+print "f = m(", minterms, ") + d(", dont_cares, ") is:"
+puts
+solution.display_sol

data/lib/quine_mc.rb

@@ -0,0 +1,41 @@
+require "quine_mc/version"
+require 'quine_mc/epi_list'
+
+module QuineMc
+	class Quine_McClusky
+
+		def initialize(m, d)
+			@nl = find_num_lit(m, d)
+			if (m+d) == (0..2**(@nl)-1).to_a or (m+d).empty?
+				@sop = []
+				@pos = []
+			else
+				maxterms = (0...2**@nl).to_a - (m+d)
+				@sop = EPi_List.new(m, d, @nl)
+				@pos = EPi_List.new(maxterms, d, @nl)
+			end
+		end
+		
+		def find_num_lit(m, d)
+			return (m+d).max.to_s(2).size
+		end
+		
+		def display_sol
+			if !@sop.empty? and !@pos.empty?
+				print "f = "
+				@sop.each do |t|
+					print (t == @sop.last)? t.to_prod(@nl) : t.to_prod(@nl)+" + " 
+				end
+				puts
+				print "f = "
+				@pos.each do |t|
+					print t.to_sum(@nl)
+				end
+				puts
+			else
+				puts "f = 1"
+			end
+		end
+		
+	end
+end

data/lib/quine_mc/cube.rb

@@ -0,0 +1,39 @@
+module QuineMc
+	class Cube < Array
+		
+		def num_ones
+			n = inject {|m,o| m & o}
+			count = 0
+			count += n & 1 and n >>= 1 until n == 0
+			return count
+		end
+		
+		def to_prod(n_l)
+			ls = (n_l > 26)? (0..n_l).to_a.map {|n| n = "A" << n.to_s} : ('A'..'Z').to_a[0,n_l]
+			p = ""
+			ls.each_with_index do |l, i|
+				if all? {|x| first[n_l-i-1] == x[n_l-i-1]}
+					p << (first[n_l-i-1] == 1 ? l : l+"'")
+				end
+			end
+			return p
+		end
+		
+		def to_sum(n_l)
+			ls = (n_l > 26)? (0..n_l).to_a.map {|n| n = "A" << n.to_s} : ('A'..'Z').to_a[0,n_l]
+			s = "("
+			ls.each_with_index do |l, i|
+				if all? {|x| first[n_l-i-1] == x[n_l-i-1]}
+					s << (first[n_l-i-1] == 1 ? l+"'+" : l+"+")
+				end
+			end
+			s[s.size-1] = ")"
+			return s
+		end
+		
+		def strict_subset?(b)
+			self & b == self and length < b.length
+		end
+		
+	end
+end

data/lib/quine_mc/epi_list.rb

@@ -0,0 +1,80 @@
+require 'quine_mc/pi_list'
+
+module QuineMc
+
+	class EPi_List < Array
+		attr_accessor :pi_table, :pi_list
+		
+		def initialize(m, d, n_l)
+			@n_l = n_l
+			@pi_list = Pi_List.new(m, d)
+			get_solution(m)
+		end
+		
+		def get_solution(m)
+			@pi_table = Hash.new {|h,k| h[k] = @pi_list.reject {|e| !e.include?(k)}}
+			m.each {|i| @pi_table[i]}
+			reduce
+		end
+		
+		def reduce
+			(@pi_table.empty?)? (return true) : size = 0
+			
+			while size != @pi_table.size
+				size = @pi_table.size
+				@pi_table.each do |k,v|
+					if v.length == 1
+						push(v[0])
+						v[0].each {|i| @pi_table.delete(i)}
+					end
+				end
+			end
+			
+			(@pi_table.empty?)? (return true) : dominated_rows
+		end
+		
+		def dominated_rows
+			removed = false
+			#puts @pi_table.inspect
+			(@pi_table.values.flatten(1) - self).each do |c1|
+				(@pi_table.values.flatten(1) - self).each do |c2|
+					if QuineMc::Cube.new(c1 & @pi_table.keys).strict_subset?(Cube.new(c2 & @pi_table.keys))
+						@pi_table.each {|k,v| v.delete_if {|i| i == c1}}
+						removed = true
+					end
+				end
+			end
+			(removed)? reduce : petrick
+		end
+		
+		def petrick
+			cube_i = Hash[@pi_table.values.flatten(1).uniq.zip((0...@pi_table.values.flatten(1).uniq.length).to_a)]
+			product = []
+			@pi_table.each do |k,v|
+				temp = []
+				v.each {|x| temp << cube_i[x]}
+				product << temp
+			end
+			choices = expand_s(product).uniq
+			cube_i = cube_i.invert
+			answer = choices.min {|a,b| cost(a, cube_i) <=> cost(b, cube_i)}
+			answer.each {|i| push(cube_i[i])}	
+		end
+			
+		def cost(c, h)
+			price = c.size
+			c.each {|i| price += @n_l - Math.log(h[i].length)/Math.log(2)}
+			return price
+		end
+		
+		def expand_s (sum)
+		    expand_r(sum).each {|x| x.flatten!; x.sort!; x.uniq!}
+		end
+		
+		def expand_r(exp)
+			if exp.length == 1 then return [[exp[0][0]],[exp[0][1]]] end
+			exp.length == 2 ? exp[0].product(exp[1]) : exp[0].product(expand_r(exp[1..exp.length]))
+		end
+	end
+	
+end

data/lib/quine_mc/pi_list.rb

@@ -0,0 +1,59 @@
+require 'quine_mc/cube'
+
+module QuineMc
+	class Pi_List < Array
+
+		def initialize(m, d)
+			@cube_table = order_terms((m + d).sort)
+			#puts @cube_table.inspect
+			get_pis()
+		end
+
+		#orders terms by number of set bits
+		def order_terms(uo_terms)
+			h = {}
+			uo_terms.each do |t|
+				t = Cube.new([t])
+				b = t.num_ones
+				h[b] = h[b] || Array.new
+				h[b].push(t)
+			end
+			return h
+		end
+
+		def power_of_2?(x)
+			((x != 0) and (x & (x-1) == 0))
+		end
+
+		def makes_cube?(a, b)
+			a.zip(b).all? { |x,y| power_of_2?(y-x) } and a.all? {|x| b.all? {|y| y>x} }
+		end
+
+
+		def get_pis()
+			next_table = {}
+			while !@cube_table.empty?
+				#puts @cube_table.inspect
+				@cube_table.each do |k,v|
+					if v
+						v.each do |c1|
+							if @cube_table[k+1]
+								@cube_table[k+1].each do |c2|
+									if makes_cube?(c1, c2)
+										if !next_table[k] then next_table[k] = [] end
+										next_table[k].push(Cube.new(c1+c2))
+									end
+								end
+							end
+							if c1.any? {|x| !next_table.values.flatten.include?(x)} then push(Cube.new(c1)) end
+						end
+					end
+				end
+				@cube_table = next_table
+				next_table = {}
+			end
+		end
+		
+		
+	end
+end

data/lib/quine_mc/version.rb

@@ -0,0 +1,3 @@
+module QuineMc
+  VERSION = "0.0.3"
+end

data/quine_mc.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "quine_mc/version"
+
+Gem::Specification.new do |s|
+  s.name        = "quine_mc"
+  s.version     = QuineMc::VERSION
+  s.authors     = ["Erik Formella"]
+  s.email       = ["erik.formella@tufts.edu"]
+  s.homepage    = ""
+  s.summary     = %q{Quine-McCluskey algorithm}
+  s.description = %q{Pretty much only for command line use}
+
+  s.rubyforge_project = "quine_mc"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: quine_mc
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Erik Formella
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000 Z
+dependencies: []
+description: Pretty much only for command line use
+email:
+- erik.formella@tufts.edu
+executables:
+- quine_mc
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/quine_mc
+- lib/quine_mc.rb
+- lib/quine_mc/.DS_Store
+- lib/quine_mc/cube.rb
+- lib/quine_mc/epi_list.rb
+- lib/quine_mc/pi_list.rb
+- lib/quine_mc/version.rb
+- quine_mc.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: quine_mc
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Quine-McCluskey algorithm
+test_files: []