lm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82e0500fd99881105260a6367a282628a4c9bf5365ddc717c219fe39e1df0f19
+  data.tar.gz: f69499c220e4a27a2a435a6820a708d458491bf0cde568d9fb9c4ddd277f13ed
+SHA512:
+  metadata.gz: af2de852aeaf14c17783868468dd34405ccde647db085cc2fd3c1999b91c6b4aac5ec608ed9a15116049840c436979e799f7c3894608c8dd798b727e61940ba1
+  data.tar.gz: e57c6b4f50c406ca6c1861fa9f530da28706619c3c92d1e1c9fe64e170fa195d3aec9179bfc55331afe238734d857b41a7fab8545a60a3c0cb7e24dc76307f61

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in lm.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lm"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/lm/bin_func.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Lm
+  class BinFunc
+    def initialize(products)
+      @products = products.arr
+    end
+
+    def inputlen
+      @products.first.vars.count
+    end
+
+    def max
+      (1 << inputlen) - 1
+    end
+
+    def apply(product, bitstr)
+      raise "len mismatch" if bitstr.length != product.vars.length
+
+      result = 1
+
+      inputlen.times do |x|
+        next if product.vars[x].invalid?
+
+        val = bitstr[x].to_i
+
+        val = ~val if product.vars[x].value == "0"
+
+        result &= val
+      end
+
+      result
+    end
+
+    def evaluate(num)
+      raise "number too large" if num > max
+
+      bitstr = num.to_s(2).rjust(inputlen, "0")
+
+      result = 0
+      @products.each do |product|
+        result |= apply(product, bitstr)
+      end
+
+      result
+    end
+  end
+end

data/lib/lm/implicant_chart.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Lm
+  class ImplicantChart
+    def initialize(chart, length:, step: 0)
+      @chart = chart
+      @step = step
+      @length = length
+    end
+
+    def buckets
+      @buckets ||= begin
+        rr = {}
+        @chart.each do |k, v|
+          ones = v.count("1")
+          rr[ones] ||= {}
+          rr[ones][k] = v
+        end
+        # p rr
+        rr
+      end
+    end
+
+    def keys
+      Set.new(@chart.keys)
+    end
+
+    def reduced
+      rr = {}
+      touched = Set.new
+      @length.times do |x|
+        next if buckets[x].nil?
+        next if buckets[x + 1].nil?
+
+        buckets[x].each do |num, pattern|
+          buckets[x + 1].each do |num2, pattern2|
+            diffcount = 0
+            last = 0
+            @length.times do |col|
+              if pattern[col] == "-" && pattern2[col] != "-" ||
+                 pattern2[col] == "-" && pattern[col] != "-"
+                diffcount += 2
+                last = col
+              end
+              next unless pattern[col] == "1" && pattern2[col] == "0" ||
+                          pattern2[col] == "1" && pattern[col] == "0"
+
+              diffcount += 1
+              last = col
+            end
+            next unless diffcount == 1
+
+            str = pattern.dup
+            str[last] = "-"
+            rr["#{num},#{num2}".split(",").sort.join(",").to_str] = str
+            touched << num.to_s
+            touched << num2.to_s
+          end
+        end
+      end
+
+      @chart.each do |k, v|
+        next if touched.include? k
+
+        rr[k] = v
+      end
+      ImplicantChart.new(rr, step: @step + 1, length: @length)
+    end
+
+    def soplist
+      rr = {}
+      @chart.each do |k, v|
+        rr[k] = Product.new(v)
+      end
+      rr
+    end
+
+    def variables
+      @variables ||= begin
+        vars = Set.new
+        @chart.each_key do |x|
+          x.split(",").each do |name|
+            vars << name
+          end
+        end
+        vars
+      end
+    end
+  end
+end

data/lib/lm/minimizer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Lm
+  class Minimizer
+    def initialize(output_str)
+      @output_str = output_str
+    end
+
+    def output_string
+      OutputString.new(@output_str)
+    end
+
+    def canonical
+      output_string.sop
+    end
+
+    def qcm
+      QuineMcCluskey.new(canonical.implicants)
+    end
+
+    def implicants
+      qcm.prime_implicants
+    end
+
+    def pm
+      Petrick.new(implicants)
+    end
+
+    def pos
+      POS.new(pm.string122)
+    end
+
+    def reduced_sum
+      pos.expand.reduce
+    end
+
+    def calculator
+      String122ResultSelector.new(implicants, reduced_sum)
+    end
+
+    def shortest
+      calculator.shortest
+    end
+
+    def evaluate(input)
+      BinFunc.new(shortest).evaluate(input)
+    end
+
+    def canonical_evaluate(input)
+      BinFunc.new(output_string.sop).evaluate(input)
+    end
+  end
+end

data/lib/lm/output_string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lm
+  class OutputString
+    def initialize(str)
+      @str = str
+    end
+
+    def bitcount
+      Math.log(@str.length, 2).ceil
+    end
+
+    def sop
+      res = SumOfProducts.new
+      @str.length.times do |x|
+        bitbreak = x.to_s(2).rjust(bitcount, "0")
+        next if @str[x] == "0"
+
+        prod = Product.new(bitbreak)
+        res << prod
+      end
+      res
+    end
+
+    def to_s(v = nil)
+      sop.to_s(v)
+    end
+  end
+end

data/lib/lm/petrick.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Lm
+  class Petrick
+    def initialize(chart)
+      @chart = chart
+    end
+
+    def grouplist
+      @grouplist ||= @chart.keys
+    end
+
+    # factors from the petrick table
+    def factors
+      factorlist = []
+      uncovered_columns.each do |var|
+        factor = []
+        grouplist.each_with_index do |group, idx|
+          vlist = Set.new(group.split(","))
+          factor << [idx] if vlist.include?(var)
+        end
+
+        factorlist << factor
+      end
+      factorlist + essential_rows.map { |x| [[x]] }
+    end
+
+    def essential_columns
+      @essential_columns ||= begin
+        varcounts = {}
+        grouplist.each_with_index do |group, _idx|
+          group.split(",").each do |v|
+            varcounts[v] ||= 0
+            varcounts[v] += 1
+          end
+        end
+        varcounts.select { |_k, v| v == 1 }.to_h.keys
+      end
+    end
+
+    def essential_rows
+      @essential_rows ||= begin
+        rows = []
+
+        essential_columns.each do |x|
+          grouplist.each_with_index do |group, idx|
+            vars = Set.new(group.split(","))
+            if vars.include?(x)
+              rows << idx
+              break
+            end
+          end
+        end
+        rows
+      end
+    end
+
+    def uncovered_columns
+      @uncovered_columns ||= begin
+        touched = Set.new
+        essential_rows.each do |idx|
+          touched += grouplist.to_a[idx].split(",")
+        end
+
+        @chart.variables - touched
+      end
+    end
+
+    def string122
+      factors.map { |sums| sums.map { |prducts| prducts.map { |x| (x.ord + 48).chr }.join("") }.join("+") }.join(",")
+    end
+  end
+end

data/lib/lm/pos.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Lm
+  # definitions
+  # A = factor
+  # AB = term
+  # AB+C = sum
+  # (AB + C)(D + E) = product of sums
+  # AB+C,D+E
+
+  class POS
+    def initialize(str)
+      @str = str
+    end
+
+    def sum_array
+      @sum_array ||= @str.split(",")
+    end
+
+    def termhash
+      @termhash ||= begin
+        res = {}
+        sum_array.each do |sum|
+          terms = sum.split("+")
+          terms.each do |term|
+            res[term] ||= Set.new
+            terms.each do |x|
+              next if x == term
+
+              res[term] << x
+            end
+          end
+        end
+        res
+      end
+    end
+
+    def apply_factorize
+      newarray = []
+      seenkeys = Set.new
+
+      termhash.each do |key, value|
+        next if seenkeys.include? key
+
+        seenkeys << key
+        value.each do |factor|
+          seenkeys << factor
+        end
+        newarray << "#{key}+#{value.to_a.join("")}"
+      end
+
+      POS.new(newarray.join(","))
+    end
+
+    # return SOP
+    def expand
+      # puts "EXPAND"
+      arr = sum_array
+
+      loop do
+        break if arr.length == 1
+
+        aterms = arr[0].split("+")
+        bterms = arr[1].split("+")
+
+        newterms = aterms.product(bterms).map do |x|
+          x.join("").split("").uniq.join("")
+        end
+
+        newsum = newterms.join("+")
+
+        arr = [newsum] + arr[2..]
+        # p arr
+      end
+
+      Sum.new(arr.first)
+    end
+  end
+end

data/lib/lm/product.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lm
+  class Product
+    attr_reader :str
+
+    def initialize(str)
+      @str = str
+    end
+
+    def vars
+      @str.split("").each_with_index.map do |x, i|
+        Variable.new(x, i)
+      end
+    end
+
+    def to_s(v = nil)
+      joiner = ""
+
+      joiner = " & " if v == :verilog || (v.is_a?(Hash) && v[:verilog])
+      vars.map { |x| x.to_s(v) }.compact.join(joiner)
+    end
+  end
+end

data/lib/lm/quine_mc_cluskey.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lm
+  class QuineMcCluskey
+    def initialize(chart)
+      @chart = chart
+    end
+
+    def prime_implicants
+      curchart = @chart
+      loop do
+        newchart = curchart.reduced
+        break if newchart.keys == curchart.keys
+
+        curchart = newchart
+      end
+      curchart
+    end
+  end
+end

data/lib/lm/string_122_result_selector.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lm
+  class String122ResultSelector
+    def initialize(pm, sum)
+      @pm = pm
+      @sum = sum
+    end
+
+    def chart
+      @chart ||= @pm.soplist.map do |k, v|
+        {
+          columns: k,
+          product: v
+        }
+      end
+    end
+
+    def sum_list
+      @sum.str.split("+").map do |term|
+        term.split("").map do |str122|
+          idx = str122.ord - 48
+          chart[idx][:product]
+        end
+      end
+    end
+
+    def sum_strings
+      sum_list.each_with_index.map { |x, i| { str: x.join("+"), idx: i } }
+    end
+
+    def shortest
+      idx = sum_strings.min_by { |x| x[:str].length }[:idx]
+      SumOfProducts.new(sum_list[idx])
+    end
+  end
+end

data/lib/lm/sum.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lm
+  class Sum
+    attr_reader :str
+
+    def initialize(str)
+      @str = str
+    end
+
+    def product_list
+      @str.split("+").map { |x| Set.new(x.split("")) }
+    end
+
+    def by_length
+      product_list.sort(&:length)
+    end
+
+    def reduce
+      res = []
+      arr = by_length
+
+      loop do
+        cur = arr.shift
+
+        newarr = []
+        arr.each do |x|
+          # remove supersets (X + XY = X)
+          next if cur.subset?(x)
+
+          newarr << x
+        end
+        res << cur
+        arr = newarr
+
+        break if arr.length.zero?
+      end
+
+      res
+      Sum.new(res.map { |x| x.to_a.join("") }.join("+"))
+    end
+  end
+end

data/lib/lm/sum_of_products.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lm
+  class SumOfProducts
+    attr_reader :arr
+
+    def initialize(arr = [])
+      @arr = arr
+    end
+
+    def <<(value)
+      insert(value)
+    end
+
+    def insert(product)
+      @arr << product
+    end
+
+    def implicants
+      result = {}
+      @arr.each do |x|
+        result[x.str.to_i(2).to_s] = x.str
+      end
+      ImplicantChart.new(result, length: @arr.first.str.length)
+    end
+
+    def to_s(v = nil)
+      joiner = "+"
+      joiner = " | " if v == :verilog || (v.is_a?(Hash) && v[:verilog])
+      @arr.map { |x| x.to_s(v) }.join(joiner)
+    end
+  end
+end

data/lib/lm/variable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Lm
+  class Variable
+    attr_reader :value
+
+    def initialize(value, pos)
+      @value = value
+      @pos = pos
+    end
+
+    def invalid?
+      @value != "1" && @value != "0"
+    end
+
+    def notop
+      @value == "0" ? "~" : ""
+    end
+
+    def bar
+      @value == "0" ? "\u0305" : ""
+    end
+
+    def subscript
+      result = ""
+
+      @pos.to_s.split("").each do |digit|
+        result += (0x2080 + digit.to_i).chr("UTF-8")
+      end
+
+      result
+    end
+
+    LETTERS = %(ABCDEFGHJKLMNPQRSTUVWXYZ)
+
+    def to_abc(letters = LETTERS)
+      return to_x if @pos >= letters.length
+      return "" if invalid?
+
+      letters[@pos] + bar
+    end
+
+    def to_x(input = "X")
+      return "" if invalid?
+
+      input.to_s + bar + subscript
+    end
+
+    def to_verilog(letter)
+      return nil if invalid?
+
+      "#{notop}#{letter}[#{@pos}]"
+    end
+
+    def to_s(input = nil)
+      input ||= LETTERS
+      if input.is_a?(String) && input.end_with?("#")
+        to_x(input[0])
+      elsif input == :verilog
+        to_verilog(x)
+      elsif input.is_a?(Hash) && input[:verilog]
+        to_verilog(input[:verilog])
+      else
+        to_abc(input)
+      end
+    end
+  end
+end

data/lib/lm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lm
+  VERSION = "0.1.0"
+end

data/lib/lm.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Lm
+  class Error < StandardError; end
+end
+
+require_relative "lm/version"
+require_relative "lm/variable"
+require_relative "lm/product"
+require_relative "lm/implicant_chart"
+require_relative "lm/quine_mc_cluskey"
+require_relative "lm/sum_of_products"
+require_relative "lm/petrick"
+require_relative "lm/output_string"
+require_relative "lm/pos"
+require_relative "lm/sum"
+require_relative "lm/string_122_result_selector"
+require_relative "lm/bin_func"
+require_relative "lm/minimizer"

data/lm.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/lm/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "lm"
+  spec.version = Lm::VERSION
+  spec.authors = ["David Siaw"]
+  spec.email = ["davidsiaw@gmail.com"]
+
+  spec.summary = "Logic Minimizer"
+  spec.description = "Logic Minimizer Library"
+  spec.homepage = "https://github.com/davidsiaw/lm"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/davidsiaw/lm"
+  spec.metadata["changelog_uri"] = "https://github.com/davidsiaw/lm"
+
+  spec.files         = Dir["{data,exe,lib,bin}/**/*"] + %w[Gemfile lm.gemspec]
+  spec.test_files    = Dir["spec/**/*"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/spec/lm_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Lm do
+  it "has a version number" do
+    expect(Lm::VERSION).not_to be nil
+  end
+
+  it "returns expected xor" do
+    min = Lm::Minimizer.new("0110")
+    expect(min.evaluate(0)).to eq 0
+    expect(min.evaluate(1)).to eq 1
+    expect(min.evaluate(2)).to eq 1
+    expect(min.evaluate(3)).to eq 0
+    expect(min.shortest.to_s(verilog: "a")).to eq "~a[0] & a[1] | a[0] & ~a[1]"
+  end
+
+  it "returns expected and" do
+    min = Lm::Minimizer.new("0001")
+    expect(min.evaluate(0)).to eq 0
+    expect(min.evaluate(1)).to eq 0
+    expect(min.evaluate(2)).to eq 0
+    expect(min.evaluate(3)).to eq 1
+    expect(min.shortest.to_s(verilog: "a")).to eq "a[0] & a[1]"
+  end
+
+  it "returns expected or" do
+    min = Lm::Minimizer.new("0111")
+    expect(min.shortest.to_s(verilog: "a")).to eq "a[1] | a[0]"
+  end
+
+  it "returns expected nand" do
+    min = Lm::Minimizer.new("1110")
+    expect(min.shortest.to_s(verilog: "a")).to eq "~a[0] | ~a[1]"
+  end
+
+  it "return canonical" do
+    min = Lm::Minimizer.new("1110")
+    expect(min.canonical.to_s(verilog: "a")).to eq "~a[0] & ~a[1] | ~a[0] & a[1] | a[0] & ~a[1]"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "lm"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: lm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Siaw
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-23 00:00:00.000000000 Z
+dependencies: []
+description: Logic Minimizer Library
+email:
+- davidsiaw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- bin/console
+- bin/setup
+- lib/lm.rb
+- lib/lm/bin_func.rb
+- lib/lm/implicant_chart.rb
+- lib/lm/minimizer.rb
+- lib/lm/output_string.rb
+- lib/lm/petrick.rb
+- lib/lm/pos.rb
+- lib/lm/product.rb
+- lib/lm/quine_mc_cluskey.rb
+- lib/lm/string_122_result_selector.rb
+- lib/lm/sum.rb
+- lib/lm/sum_of_products.rb
+- lib/lm/variable.rb
+- lib/lm/version.rb
+- lm.gemspec
+- spec/lm_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/davidsiaw/lm
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/davidsiaw/lm
+  source_code_uri: https://github.com/davidsiaw/lm
+  changelog_uri: https://github.com/davidsiaw/lm
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Logic Minimizer
+test_files:
+- spec/lm_spec.rb
+- spec/spec_helper.rb