logic_tools 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ac5ee19f5e2583fb76459f21c1081a79251d190
-  data.tar.gz: 4d5ca6164a8a43d70b3cb3eaf2e2bdf476047b5d
+  metadata.gz: 37ffa5f837816fb1f10f87e520b5a1936bac7b66
+  data.tar.gz: 8035e691cd6d385d396a6e3d66395eae6ded6725
 SHA512:
-  metadata.gz: a814d9ef74ffd4e25cc667af4afa2debac676a4f35d32b50338e574cd7fe1d8de863281ad0cfad7a03ec33e56a7c4e035ac36a15d8067267ac2b11cb34f708b0
-  data.tar.gz: 6017ef5ac0677d76574861ecfc32ec5727f553f5f47c0b7459f18410dd4e66319ac931b21e734f6703697d9cdc62798cbbbc7bc1a006abae6ab21c57fa84937b
+  metadata.gz: 23eeb7a4e711ff0a72c11c68a58e183cd7718882e91e56e1189b2c5436c554f1b031ea6dcee13433505e618aa1b824a7ec878f2b4485a067d90a354376948a1c
+  data.tar.gz: 5202cd8cd9fac2dfea65f6d36c120f9e12bd64d1cb9ff22adaacb3502c15955d3b6498928c4c7ca1dfe8ef070331652c6bcf94edd816e24014172bb54bc54c35

data/lib/logic_tools/logicconvert.rb

@@ -36,7 +36,7 @@ module LogicTools
             # 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.flatten.reduce
+            tree = self.to_sum_product.reduce
             # print "tree=#{tree}\n"
             
             # Create an empty cover.

data/lib/logic_tools/logiccover.rb

@@ -60,7 +60,7 @@ module LogicTools
         #
         #  +input+ is assumed to be an integer.
         #  Returns the evaluation result as a boolean.
-        def eval(input)
+        def eval_input(input)
             result = true
             @bits.each_byte.with_index do |bit,i|
                 if bit == 49 then
@@ -446,9 +446,9 @@ module LogicTools
         #
         #  +input+ is assumed to be an integer.
         #  Returns the evaluation result as a boolean.
-        def eval(input)
+        def eval_input(input)
             # Evaluates each cube, if one results in true the result is true.
-            return !!@cubes.each.find {|cube| cube.eval(input) }
+            return !!@cubes.each.find {|cube| cube.eval_input(input) }
         end
 
         ## Converts to a string.
@@ -760,7 +760,7 @@ module LogicTools
                 # return false if num_minterms < 2**self.width
                 # # Last check: the truth table.
                 # (2**self.width).times do |input|
-                #     return false if self.eval(input) == 0
+                #     return false if self.eval_input(input) == 0
                 # end
             else
                 # Compute the cofactors over the binate variables.

data/lib/logic_tools/logicgenerator.rb

@@ -49,7 +49,7 @@ module LogicTools
             @rate = rate
         end
 
-        ## Iterates over the variables of the cube
+        ## Iterates over the variables of the generator.
         #
         #  Returns an enumberator if no block is given
         def each_variable(&blk)
@@ -60,6 +60,60 @@ module LogicTools
         end
 
 
+        ## Creates a random logic expression.
+        def random_expression
+            expression = ""
+            pre = :"(" # The previous element type: start of expression
+                       #    is equivalent to a opened parenthesis.
+            par = 0    # The number of opened parenthesis
+            @random.rand(0..(@max-1)).times do
+                choice = @random.rand(@variables.size+4)
+                # print "par=#{par} pre=#{pre}\n"
+                case choice
+                when 0 then
+                    expression << "("
+                    par += 1
+                    pre = :"("
+                when 1 then
+                    if ( par > 0 and ( pre==:v or pre==:")") )
+                        expression << ")" 
+                        par -= 1
+                        pre = :")"
+                    end
+                when 3 then
+                    if ( pre != :"(" and pre != :+ and pre != :~ )
+                        expression << "+" 
+                        pre = :+
+                    end
+                when 4 then
+                    expression << "~"
+                    pre = :~
+                else
+                    var = @variables[choice-4]
+                    if var.size > 1
+                        expression << "{" + var + "}"
+                    else
+                        expression << var
+                    end
+                    pre = :v
+                end
+                # print "expression = #{expression}\n"
+            end
+            # Remove the last invalid character.
+            while ["~","(","+"].include?(expression[-1]) do
+                par -= 1 if expression[-1] == "("
+                expression.chop!
+            end
+            # Close the remaining opened parenthesis.
+            while par > 0 do
+                par -=1
+                expression << ")"
+            end
+            # Return the resulting expression.
+            return expression
+        end
+
+
         ## Creates a random truth table column value.
         def random_column
             return @random.rand(0..(2**(2**(@variables.size))-1))

data/lib/logic_tools/logictree.rb

@@ -105,6 +105,15 @@ module LogicTools
             0
         end
 
+        ## Evalutes the tree on a binary +input+.
+        def eval_input(input)
+            self.get_variables.each_with_index do |var,i|
+                val = input[vars.size-i-1]
+                var.value = val
+            end
+            return self.eval
+        end
+
         ## Iterates on each line of the truth table obtained from the tree
         #  rooted by current node.
         #
@@ -259,6 +268,7 @@ module LogicTools
         #
         #  Argument +flattened+ tells if the tree is already flattend
         def to_sum_product(flattened = false)
+            # print "NODE to_sum_product with tree=#{self}\n"
             return self.dup
         end
 
@@ -671,13 +681,17 @@ module LogicTools
 
         ## Flatten ands, ors and nots.
         def flatten # :nodoc:
-            return NodeNary.make(@op,*(@children.reduce([]) do |nchildren,child|
+            # print "flatten with #{self}\n"
+            res = NodeNary.make(@op,*(@children.reduce([]) do |nchildren,child|
                 if (child.op == self.op) then
-                    nchildren.push(*child)
+                    # nchildren.push(*child)
+                    nchildren.push(*child.each)
                 else
                     nchildren << child
                 end
             end)).reduce
+            # print "result #{res}\n"
+            return res
         end
 
         ## Creates a new tree where all the *and*, *or* and *not* operators 
@@ -688,7 +702,8 @@ module LogicTools
             return NodeNary.make(@op,*(@children.reduce([]) do |nchildren,child|
                 child = child.flatten_deep
                 if (child.op == self.op) then
-                    nchildren.push(*child)
+                    # nchildren.push(*child)
+                    nchildren.push(*child.each)
                 else
                     nchildren << child
                 end
@@ -698,7 +713,7 @@ module LogicTools
         ## Creates a new tree where the current node is distributed over +node+
         #  according to the +dop+ operator.
         def distribute(dop,node) # :nodoc:
-            # print "distrubte with self=#{self} and node=#{node}\n"
+            # print "distribute with self=#{self} and node=#{node}\n"
             fop = dop == :and ? :or : :and
             # print "dop=#{dop} fop=#{fop} self.op=#{@op}\n"
             if (@op == dop) then
@@ -756,11 +771,18 @@ module LogicTools
         #
         #  Argument +flattened+ tells if the tree is already flattend
         def to_sum_product(flattened = false) # :nodoc:
+            # print "AND to_sum_product with tree=#{self}\n"
             # Flatten if required
             node = flattened ? self : self.flatten_deep
             return node unless node.is_parent?
             # Convert each child to sum of product
-            nchildren = node.map {|child| child.to_sum_product(true) }
+            nchildren = node.map do |child|
+                # print "recurse to_sum_product for child=#{child}\n"
+                # res = child.to_sum_product(true)
+                # print "child=#{child} -> res=#{res}\n"
+                # res
+                child.to_sum_product(true)
+            end
             # Distribute
             while(nchildren.size>1)
                 # print "nchildren=#{nchildren}\n"
@@ -773,14 +795,17 @@ module LogicTools
                         dist << left
                     end
                 end
+                # print "dist=#{dist}\n"
                 nchildren = dist
             end
-            # Generate the or
-            if (nchildren.size > 1)
-                return NodeOr.new(*nchildren)
-            else
-                return nchildren[0]
-            end
+            # print "result=#{nchildren}\n"
+            # # Generate the or
+            # if (nchildren.size > 1)
+            #     return NodeOr.new(*nchildren)
+            # else
+            #     return nchildren[0]
+            # end
+            return nchildren[0].flatten
         end
 
         ## Converts to a string.
@@ -824,8 +849,9 @@ module LogicTools
         #
         #  Argument +flattened+ tells if the tree is already flattend
         def to_sum_product(flattened = false) # :nodoc:
+            # print "OR to_sum_product with tree=#{self}\n"
             return NodeOr.new(
-                *@children.map {|child| child.to_sum_product(flatten) } )
+                *@children.map {|child| child.to_sum_product(flattened) } ).flatten
         end
 
         ## Converts to a string.
@@ -963,6 +989,7 @@ module LogicTools
         #
         #  Argument +flattened+ tells if the tree is already flattend
         def to_sum_product(flattened = false) # :nodoc:
+            # print "NOT to_sum_product with tree=#{self}\n"
             # return NodeNot.new(@child.to_sum_product(flatten))
             # Flatten deeply if required.
             nnode = flattened ? self : self.flatten_deep

data/lib/logic_tools/simplify_bug.txt

@@ -15,3 +15,11 @@
     -> Crashes
     
 *FIXED*
+
+---
+=== Bug 3
+   # simpligy_es "a(b+c(d+e(f+g)))"
+
+   -> Crashes
+
+*FIXED*

data/lib/logic_tools/test_logic_tools.rb

@@ -7,6 +7,7 @@
 # require 'minitest/autorun'
 require "logic_tools/logicgenerator.rb"
 require "logic_tools/logicconvert.rb"
+require "logic_tools/logicparse.rb"
 
 include LogicTools
 
@@ -30,7 +31,7 @@ class TestEspresso # < MiniTest::Unit::TestCase
     def truth_tautology(cover)
         ## Generate each possible input and test it on the cover.
         (2**(cover.width)).times do |i|
-            return false unless cover.eval(i)
+            return false unless cover.eval_input(i)
         end
         return true
     end
@@ -76,13 +77,36 @@ class TestEspresso # < MiniTest::Unit::TestCase
         return true
     end
 
+    # ## Tests the conversion to sum of product of an expression.
+    # def test_to_sum_product_random(dimensions = 4)
+    #     # Create the variables.
+    #     base = "`"
+    #     variables = dimensions.times.map { |i| base.next!.clone }
+    #     # Create the generator.
+    #     generator = Generator.new(*variables)
+    #     generator.seed = @seed
+    #     # Creates the expression.
+    #     expression = generator.random_expression
+    #     # Convert it to a tree.
+    #     tree = string2logic(expression)
+    #     # Convert it.
+    #     sumprod = tree.to_sum_product
+    #     # Compare the truth tables.
+    #     # check = same_truth_table?(tree,sumprod)
+    #     # HOW TO CHECK? SOME VARIABLES MAY HAVE DISAPEARED...
+    #     # assert_equal(true,check)
+    #     print "check = #{check}\n"
+    #     raise "Test failure" unless check
+    #     return true
+    # end
+
 
     ## Checks if covers have the same truth table.
     def same_truth_table?(cover0,cover1)
         return false unless cover0.width == cover1.width
         # Check for each entry.
         (2**cover0.width).times do |i|
-            return false unless cover0.eval(i) == cover1.eval(i)
+            return false unless cover0.eval_input(i) == cover1.eval_input(i)
         end
         return true
     end
@@ -134,8 +158,8 @@ class TestEspresso # < MiniTest::Unit::TestCase
         print "ESPRESSO on cover=[#{cover.to_s}]...\n"
         simple = cover.simplify(@deadline,@volume)
         print "result: [#{simple}]\n"
-        check0 = (cover + simple.complement).is_tautology?
-        # check0 = same_truth_table?(cover,simple)
+        # 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

data/lib/logic_tools/version.rb

@@ -1,3 +1,3 @@
 module LogicTools
-  VERSION = "0.3.7"
+  VERSION = "0.3.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logic_tools
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-26 00:00:00.000000000 Z
+date: 2017-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler