logic_tools 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3959c85da2264b72f5ae3a4b0fe8eda6cfab768
-  data.tar.gz: 0424225bcee4edac9f7e161024b61c9427aa91a1
+  metadata.gz: 84eda2845101b1b4e6e59e9ad408f4d2e246e930
+  data.tar.gz: f2b8eaa53ef5b7f14e7a93240a12acc122021d92
 SHA512:
-  metadata.gz: ba63032be6f4b07afadab832f410f4b365132ac89fd5f0e7e926b9413e7de3d7e6f96cca1a710b187e18c0599681ba1002a86c1dab2b8997b882f110c773a8a2
-  data.tar.gz: fb61f85742828cae87c0ac3ff377ffef9a51c0cb4a740f52bf6da16b0a73565f8505302799acddc5c024b5065c017b4340cedde8dba2917d74b3e72c61a492e6
+  metadata.gz: b13d4bb1a6227c6abc413296077d374dbbf833b701830ebf5a5d2ad24ef7c13e9a8561367a7ccd67db7bcfb1044c1bfdd5b1755142858ea082d704f6e54a91ca
+  data.tar.gz: 57e5fd61601d088914c024c812b5310474dbd6c526c70169ddacb16098f47e40bf798aa40697156bae67b16c81d9bfb4194180a4192ccd07ed728c2da11e5455

data/README.md

@@ -101,6 +101,6 @@ The gem is available as open source under the terms of the [MIT License](http://
 
 
 ## To do
-* Update the code of simplify_qm so that it uses the optimized LogicTool::Cover class and minimal\_column\_covers methods.
+* Update the code of simplify_qm so that it uses the optimized LogicTool::Cover class.
 
 

data/lib/logic_tools/logicconvert.rb

@@ -13,19 +13,27 @@ require "logic_tools/logiccover.rb"
 module LogicTools
 
     class Node
-        ## Converts to a cover.
-        def to_cover()
+        ## Converts to a cover of a boolean space based of +variables+.
+        #  
+        #  NOTE: the variables of the space are also extracted from +self+.
+        def to_cover(*variables)
             # Check the cases of trivial trees.
             if self.is_a?(NodeTrue) then
-                cover = Cover.new("all")
-                cover << Cube.new("-")
+                if variables.empty? then
+                    cover = Cover.new("all")
+                    cover << Cube.new("-")
+                else
+                    cover = Cover.new(*variables)
+                    cover << Cube.new("-"*variables.size)
+                end
                 return cover
             elsif self.is_a?(NodeFalse) then
-                return Cover.new()
+                return Cover.new(*variables)
             end
 
             # Get the variables for converting them to indexes in the cubes
-            vars = self.get_variables
+            vars = (variables + self.get_variables.map(&:to_s)).uniq
+            # print "vars=#{vars}\n"
             # Converts the tree rooted by self to a sum of products
             # (reduced to limit the number of cubes and their sizes).
             tree = self.to_sum_product.reduce
@@ -45,16 +53,25 @@ module LogicTools
                 return cover
             when :variable then
                 # Single variable
-                cover << Cube.new("1")
+                str = "-" * cover.width
+                index = vars.index(tree.variable.to_s)
+                str[index] = "1"
+                cover << Cube.new(str)
                 return cover
             when :not then
                 # Single complement of a variable
-                cover << Cube.new("0")
+                str = "-" * cover.width
+                index = vars.index(tree.child.variable.to_s)
+                str[index] = "0"
+                cover << Cube.new(str)
                 return cover
             end
 
             # Treat the other cases.
 
+            # Ensure we have a sum of product structure.
+            tree = [ tree ] unless tree.op == :or
+
             # Fill it with the cubes corresponding to each product
             tree.each do |product|
                 product = [ product ] unless product.is_a?(NodeNary)
@@ -63,7 +80,7 @@ module LogicTools
                 str = "-"*vars.size
                 product.each do |lit|
                     if lit.is_a?(NodeNot) then
-                        index = vars.index(lit.child.variable)
+                        index = vars.index(lit.child.variable.to_s)
                         # The litteral is a not
                         if str[index] == "1" then
                             # But it was "1" previously, contradictory cube:
@@ -75,7 +92,7 @@ module LogicTools
                             str[index] = "0"
                         end
                     else
-                        index = vars.index(lit.variable)
+                        index = vars.index(lit.variable.to_s)
                         # The litteral is a variable
                         if str[index] == "0" then
                             # But it was "0" previously, contradictory cube:

data/lib/logic_tools/logicgenerator.rb

@@ -113,6 +113,8 @@ module LogicTools
                     terms << make_minterm(i)
                 end
             end
+            # If no term, return a NodeFalse
+            return NodeFalse.new if terms.empty?
             # Generate and return the resulting sum.
             return NodeOr.new(*terms)
         end

data/lib/logic_tools/logicparse.rb

@@ -25,7 +25,7 @@ module LogicTools
         # rule(:var) { match('[A-Za-uw-z]') }
         rule(:var) do
             match('[A-Za-z]') |
-            str("{") >> ( match('[a^Za-z]').repeat ) >> str("}")
+            str("{") >> ( match('[0-9A-Za-z]').repeat ) >> str("}")
         end
         # And operator
         # rule(:andop) { str("&&") | match('[&\.\*^]') }

data/lib/logic_tools/logicsimplify_qm.rb

@@ -7,6 +7,7 @@
 require 'set'
 
 require "logic_tools/logictree.rb"
+require "logic_tools/minimal_column_covers.rb"
 
 module LogicTools
 
@@ -252,6 +253,11 @@ module LogicTools
         #
         #  Uses the Quine-Mc Cluskey method.
         def simplify
+            # Step 0 checks the trivial cases.
+            if self.op == :true or self.op == :false then
+                return self.clone
+            end
+
             # Step 1: get the generators
             
             # Gather the minterms which set the function to 1 encoded as
@@ -324,55 +330,97 @@ module LogicTools
             # print "generators with covers:\n"
             # generators.each {|gen| print gen,": ", gen.covers,"\n" }
 
-            # Step 2: remove the redundancies
-            
-            # Select the generators using Petrick's method
-            # For that purpose treat the generators as variables
-            variables = generators.map {|gen| VarImp.new(gen) }
+            # Step 2: remove the redundancies by finding the minimal column
+            # sets cover from the generators.
             
-            # Group the variables by cover
+            # # Select the generators using Petrick's method
+            # # For that purpose treat the generators as variables
+            # variables = generators.map {|gen| VarImp.new(gen) }
+            # 
+            # # Group the variables by cover
+            # cover2gen = Hash.new { |h,k| h[k] = [] }
+            # variables.each do |var|
+            #     # print "var=#{var}, implicant=#{var.implicant}, covers=#{var.implicant.covers}\n"
+            #     var.implicant.covers.each { |cov| cover2gen[cov] << var }
+            # end
+            # # Convert this hierachical table to a product of sum
+            # # First the sum terms
+            # sums = cover2gen.each_value.map do |vars|
+            #     # print "vars=#{vars}\n"
+            #     if vars.size > 1 then
+            #         NodeOr.new(*vars.map {|var| NodeVar.new(var) })
+            #     else
+            #         NodeVar.new(vars[0])
+            #     end
+            # end
+            # # print "sums = #{sums.to_s}\n"
+            # # Then the product
+            # # expr = NodeAnd.new(*sums).uniq
+            # if sums.size > 1 then
+            #     expr = NodeAnd.new(*sums).reduce
+            # else
+            #     expr = sums[0]
+            # end
+            # # Convert it to a sum of product
+            # # print "expr = #{expr.to_s}\n"
+            # expr = expr.to_sum_product(true)
+            # # print "Now expr = #{expr.to_s} (#{expr.class})\n"
+            # # Select the smallest term (if several)
+            # if (expr.op == :or) then
+            #     smallest = expr.min_by do |term|
+            #         term.op == :and ? term.size : 1
+            #     end
+            # else
+            #     smallest = expr
+            # end
+            # # The corresponding implicants are the selected generators
+            # if smallest.op == :and then
+            #     selected = smallest.map {|term| term.variable.implicant }
+            # else
+            #     selected = [ smallest.variable.implicant ]
+            # end
+           
+            # Creates the matrix for looking for the minimal column cover:
+            # the rows stands for the covers and the columns stands for the
+            # generator. A "1" indicates a cover is obtained from the
+            # corresponding generator.
+            matrix = []
+            # Set the index table of the generators for faster lookup.
+            gen2index = {}
+            generators.each.with_index { |gen,i| gen2index[gen] = i }
+            # Group the generators by cover
             cover2gen = Hash.new { |h,k| h[k] = [] }
-            variables.each do |var|
-                # print "var=#{var}, implicant=#{var.implicant}, covers=#{var.implicant.covers}\n"
-                var.implicant.covers.each { |cov| cover2gen[cov] << var }
+            generators.each do |gen|
+                # print "gen=#{gen}, covers=#{gen.covers}\n"
+                gen.covers.each { |cover| cover2gen[cover] << gen }
             end
-            # Convert this hierachical table to a product of sum
-            # First the sum terms
-            sums = cover2gen.each_value.map do |vars|
-                # print "vars=#{vars}\n"
-                if vars.size > 1 then
-                    NodeOr.new(*vars.map {|var| NodeVar.new(var) })
-                else
-                    NodeVar.new(vars[0])
-                end
+            # Fill the matrix with it.
+            cover2gen.each do |cover,gens|
+                # print "cover=#{cover}, gens=#{gens}\n"
+                row = "0" * generators.size
+                # Set the "1" (49 in byte).
+                gens.each { |gen| row.setbyte(gen2index[gen],49) }
+                matrix << row
             end
-            # print "sums = #{sums.to_s}\n"
-            # Then the product
-            # expr = NodeAnd.new(*sums).uniq
-            if sums.size > 1 then
-                expr = NodeAnd.new(*sums).reduce
-            else
-                expr = sums[0]
-            end
-            # Convert it to a sum of product
-            # print "expr = #{expr.to_s}\n"
-            expr = expr.to_sum_product(true)
-            # print "Now expr = #{expr.to_s} (#{expr.class})\n"
-            # Select the smallest term (if several)
-            if (expr.op == :or) then
-                smallest = expr.min_by do |term|
-                    term.op == :and ? term.size : 1
-                end
-            else
-                smallest = expr
-            end
-            # The corresponding implicants are the selected generators
-            if smallest.op == :and then
-                selected = smallest.map {|term| term.variable.implicant }
-            else
-                selected = [ smallest.variable.implicant ]
+            # Find the minimal column cover.
+            # print "matrix=#{matrix}\n"
+            cols = minimal_column_covers(matrix, true) 
+
+            # Get the selected generators (implicants).
+            selected = cols.map { |col| generators[col] }
+
+            # Handle the trivial case
+            if selected.empty? then
+                # false case.
+                return NodeFlase.new
+            elsif selected.size == 1 and 
+                ! selected[0].each.find {|c| c == "1" or c == "0" }
+                # true case
+                return NodeTrue.new
             end
 
+            # The other cases
+
             # Sort by variable order
             selected.sort_by! { |implicant| implicant.bits }
 

data/lib/logic_tools/minimal_column_covers.rb

@@ -120,9 +120,13 @@ module LogicTools
         def solve()
             # Solve the problem throughly.
             begin
-                Timeout::timeout(@deadline) {
-                    self.branch(0)
-                }
+                if @deadline != Float::INFINITY then
+                    Timeout::timeout(@deadline) {
+                        self.branch(0)
+                    }
+                else
+                        self.branch(0)
+                end
             rescue Timeout::Error
                 # Time out, is there a solution?
                 # print "Timeout!\n"

data/lib/logic_tools/simplify_es.rb

@@ -32,6 +32,7 @@ each_input do |expr|
 
     # Simplify it
     simple = parsed.simplify
+    simple = simple.sort
     # print "Computation done\n"
  
     # Display the result

data/lib/logic_tools/test_logic_tools.rb

@@ -5,8 +5,8 @@
 ######################################################################
 
 # require 'minitest/autorun'
-require "logic_tools/logicsimplify_es.rb"
 require "logic_tools/logicgenerator.rb"
+require "logic_tools/logicconvert.rb"
 
 include LogicTools
 
@@ -18,6 +18,9 @@ class TestEspresso # < MiniTest::Unit::TestCase
     #  the cover.
     def initialize(seed = 0, deadline = Float::INFINITY,
                                volume = Float::INFINITY)
+        # Ensures ESPRESSO is used.
+        load "logic_tools/logicsimplify_es.rb"
+
         @seed = seed
         @deadline = deadline
         @volume = volume
@@ -85,6 +88,47 @@ class TestEspresso # < MiniTest::Unit::TestCase
     end
 
 
+    ## Tests Quine Mac Cluskey on a given +tree+.
+    def test_qm(tree)
+        print "Quine Mc Cluskey algorithm on expression=[#{tree}]...\n"
+        simple = tree.simplify()
+        print "result: [#{tree}]\n"
+        cover = tree.to_cover
+        check0 = (cover + simple.complement).is_tautology?
+        # check0 = same_truth_table?(cover,simple)
+        # assert_equal(true,check0)
+        print "check 0 = #{check0}\n"
+        raise "Test failure" unless check0
+        check1 = (cover.complement + simple).is_tautology?
+        # assert_equal(true,check1)
+        print "check 1 = #{check1}\n"
+        raise "Test failure" unless check1
+        return true
+    end
+
+    ## Tests the implementation of the espresso algorithm on each
+    #  possible 1-cube cover of 4 variables.
+    #
+    #  Test only on cover if a +test+ number is given.
+    def test_qm_all(test = nil)
+        generator = Generator.new("a","b","c","d")
+        generator.seed = @seed
+        if test then
+            test = test.to_i
+            print "Test #{test}: "
+            return test_qm(generator.make_std_conj(test))
+        else
+            generator.each_std_conj.with_index do |tree,i|
+                print "Test #{i}: "
+                return false unless test_qm(tree)
+            end
+            return true
+        end
+    end
+
+
+
+
     ## Tests espresso on a given +cover+.
     def test_espresso(cover)
         print "ESPRESSO on cover=[#{cover.to_s}]...\n"
@@ -159,3 +203,57 @@ class TestEspresso # < MiniTest::Unit::TestCase
     end
 
 end
+
+
+## Class for testing the implementation Quine Mc Cluskey algorithm.
+class TestQM
+
+    ## Creates the tester with a +seed+ for random generation.
+    def initialize(seed = 0)
+        # Ensures QM is used.
+        load "logic_tools/logicsimplify_qm.rb"
+        @seed = seed
+    end
+
+    ## Tests Quine Mac Cluskey on a given +tree+.
+    def test_qm(tree,generator)
+        print "Quine Mc Cluskey algorithm on expression=[#{tree}]...\n"
+        simple = tree.simplify()
+        print "result: [#{simple}]\n"
+        cover = tree.to_cover(*generator.each_variable)
+        # print "cover=#{cover}\n"
+        simple_cover = simple.to_cover(*generator.each_variable)
+        # print "simple_cover=#{simple_cover}\n"
+        check0 = (cover + simple_cover.complement).is_tautology?
+        # check0 = same_truth_table?(cover,simple)
+        # assert_equal(true,check0)
+        print "check 0 = #{check0}\n"
+        raise "Test failure" unless check0
+        check1 = (cover.complement + simple_cover).is_tautology?
+        # assert_equal(true,check1)
+        print "check 1 = #{check1}\n"
+        raise "Test failure" unless check1
+        return true
+    end
+
+    ## Tests the implementation of the espresso algorithm on each
+    #  possible 1-cube cover of 4 variables.
+    #
+    #  Test only on cover if a +test+ number is given.
+    def test_qm_all(test = nil)
+        generator = Generator.new("a","b","c","d")
+        generator.seed = @seed
+        if test then
+            test = test.to_i
+            print "Test #{test}: "
+            return test_qm(generator.make_std_conj(test),generator)
+        else
+            generator.each_std_conj.with_index do |tree,i|
+                print "Test #{i}: "
+                return false unless test_qm(tree,generator)
+            end
+            return true
+        end
+    end
+
+end

data/lib/logic_tools/version.rb

@@ -1,3 +1,3 @@
 module LogicTools
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logic_tools
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Lovic Gauthier