logic_tools 0.2.4 → 0.3.0

data/lib/logic_tools/{logicsimplify.rb → logicsimplify_qm.rb}

@@ -6,6 +6,7 @@
 
 require 'set'
 
+require "logic_tools/logictree.rb"
 
 module LogicTools
 
@@ -69,7 +70,7 @@ module LogicTools
             @prime = true # By default assumed prime
         end
 
-        ## Converts to a string
+        ## Converts to a string.
         def to_s # :nodoc:
             @bits
         end
@@ -84,7 +85,13 @@ module LogicTools
         end
 
         ## Iterates over the bits of the implicant.
+        # 
+        #  Returns an enumerator if no block given.
         def each(&blk)
+            # No block given? Returns an enumerator
+            return to_enum(:each) unless block_given?
+            
+            # Block given? Applies it on each bit.
             @bits.each_char(&blk)
         end
 
@@ -212,7 +219,7 @@ module LogicTools
     ## 
     #  Describes a pseudo variable associated to an implicant.
     #
-    #  Used for the Petrick's method
+    #  Used for the Petrick's method.
     class VarImp < Variable
         @@base = 0 # The index of the VarImp for building the variable names
 
@@ -371,7 +378,7 @@ module LogicTools
 
             # print "Selected prime implicants are: #{selected}\n"
             # Generate the resulting tree
-            variables = self.getVariables()
+            variables = self.get_variables()
             # First generate the prime implicants trees
             selected.map! do |prime|
                 # Generate the litterals 

data/lib/logic_tools/logictree.rb

@@ -4,6 +4,7 @@
 
 require 'forwardable'
 
+
 module LogicTools
 
     ## 
@@ -76,11 +77,18 @@ module LogicTools
         include Enumerable
 
         ## Gets a array containing the variables of the tree sorted by name.
-        def getVariables()
-            result = self.getVariablesRecurse
+        def get_variables()
+            result = self.get_variablesRecurse
             return result.flatten.uniq.sort
         end
 
+        ## Tells if the node is a parent.
+        #
+        #  Default: +false+.
+        def is_parent?
+            return false
+        end
+
         ## Gets the operator.
         #
         #  Default: +nil+ (none).
@@ -107,7 +115,7 @@ module LogicTools
 
             # Block given? Apply it.
             # Get the variables
-            vars = self.getVariables
+            vars = self.get_variables
             # Compute the number of iterations
             nlines = 2**vars.size
             # Generates each bit value for the variables and the
@@ -209,19 +217,32 @@ module LogicTools
         #
         #  Default: simply duplicate.
         def flatten_deep
+            # print "flatten_deep #1 with self=#{self}\n"
             return self.dup
         end
 
+        ## Reduce the node by removing redundancy from it.
+        #
+        #  NOTE: this is not the same purpose a Enumerable::reduce.
+        def reduce
+            # By default, no possible reduction.
+            self.clone
+        end
+
         ## Creates a new tree where the current node is distributed over +node+
         #  according to the +dop+ operator.
         def distribute(dop,node)
             fop = dop == :and ? :or : :and
-            # print "dop=#{dop}, fop=#{fop}, node.op=#{node.op}\n"
             if (node.op == dop) then
                 # Same operator: merge self in node
                 return NodeNary.make(dop, self, *node)
             elsif (node.op == fop) then
                 # Opposite operator: can distribute
+                # result = NodeNary.make(dop)
+                # node.each do |child|
+                #     result << NodeNary.make(dop,child,self).flatten
+                # end
+                # return result.flatten
                 nchildren = node.map do |child|
                     NodeNary.make(dop,child,self).flatten
                 end
@@ -256,6 +277,18 @@ module LogicTools
         def eql?(val) # :nodoc:
             self == val
         end
+
+        ## Tells if +self+ includes +tree+.
+        def include?(tree)
+            # By default: equality comparison.
+            return self == tree
+        end
+
+        ## Tells if +self+ covers +tree+
+        def cover?(tree)
+            # By default: equality comparison.
+            return self == tree
+        end
     end
 
     
@@ -268,7 +301,8 @@ module LogicTools
         ## Creates a node by +value+.
         def initialize(value) # :nodoc:
             @value = value
-            @sym = @value.to_s.to_sym
+            # @sym = @value.to_s.to_sym
+            @sym = nil
         end
 
         public
@@ -276,7 +310,7 @@ module LogicTools
         ## Gets the variables, recursively, without postprocessing.
         #
         #  Returns the variables into sets of arrays with possible doublon
-        def getVariablesRecurse() # :nodoc:
+        def get_variablesRecurse() # :nodoc:
             return [ ]
         end
 
@@ -286,19 +320,31 @@ module LogicTools
             return self.eval() == node.eval()
         end
 
+        # Node::include? is now enough.
+        # ## Tells if the +self+ includes +tree+.
+        # def include?(tree)
+        #     return ( tree.is_a?(NodeValue) and self.eval() == tree.eval() )
+        # end
+
         ## Computes the value of the node.
         def eval
             return @value
         end
 
+        ## Gets the operator.
+        def op
+            return @value.to_s.to_sym
+        end
+
         ## Converts to a symbol.
         def to_sym # :nodoc:
+            @sym = @value.to_s.to_sym unless @sym
             return @sym
         end
 
         ## Converts to a string.
         def to_s # :nodoc:
-            return @value.to_s
+            return @value ? "1" : "0"
         end
     end
 
@@ -331,9 +377,23 @@ module LogicTools
         ## Creates a node with variable +name+.
         def initialize(name)
             @variable = Variable.get(name)
-            @sym = @variable.to_s.to_sym
+            # @sym = @variable.to_s.to_sym
+            @sym = nil
+        end
+
+        ## Gets the operator.
+        #
+        #  Default: +nil+ (none).
+        def op
+            :variable
         end
 
+        # Node::include? is now enough. 
+        # ## Tells if the +self+ includes +tree+.
+        # def include?(tree)
+        #     return ( tree.is_a?(NodeVar) and self.variable == tree.variable )
+        # end
+
         ## Computes the value of the node.
         def eval()
             return @variable.value
@@ -341,13 +401,14 @@ module LogicTools
 
         ## Converts to a symbol.
         def to_sym # :nodoc:
+            @sym = @variable.to_s.to_sym unless @sym
             return @sym
         end
 
         ## Gets the variables, recursively, without postprocessing.
         #
         #  Returns the variables into sets of arrays with possible doublon
-        def getVariablesRecurse() # :nodoc:
+        def get_variablesRecurse() # :nodoc:
             return [ @variable ]
         end
 
@@ -359,7 +420,11 @@ module LogicTools
 
         ## Converts to a string.
         def to_s # :nodoc:
-            return variable.to_s
+            result = variable.to_s
+            # Variables using more than one character are parenthesized
+            # to avoid confunsion with the AND operator.
+            result = "{" + result + "}" if (result.size > 1)
+            return result
         end
     end
 
@@ -383,7 +448,8 @@ module LogicTools
             # Children are ok
             @op = op.to_sym
             @children = children
-            @sym = self.to_s.to_sym
+            # @sym = self.to_s.to_sym
+            @sym = nil
         end
 
         public
@@ -399,10 +465,23 @@ module LogicTools
             end
         end
 
+        ## Tells if the node is a parent.
+        def is_parent?
+            return true
+        end
 
         # Also acts as an array of nodes
         def_delegators :@children, :[], :empty?, :size
 
+        ## Adds a +child+.
+        def add(child)
+            unless child.is_a?(Node) then
+                raise ArgumentError.new("Not a valid class for a child: "+
+                                        "#{child.class}")
+            end
+            @children << child
+        end
+
         ## Iterates over the children.
         def each(&blk) # :nodoc:
             # No block given? Return an enumerator.
@@ -434,15 +513,16 @@ module LogicTools
 
         ## Converts to a symbol.
         def to_sym # :nodoc:
+            @sym = self.to_s.to_sym unless @sym
             return @sym
         end
 
         ## Gets the variables, recursively, without postprocessing.
         #
         #  Returns the variables into sets of arrays with possible doublon
-        def getVariablesRecurse() # :nodoc:
+        def get_variablesRecurse() # :nodoc:
             return @children.reduce([]) do |res,child|
-                res.concat(child.getVariablesRecurse)
+                res.concat(child.get_variablesRecurse)
             end
         end
 
@@ -450,6 +530,7 @@ module LogicTools
         def ==(node) # :nodoc:
             return false unless node.is_a?(Node)
             return false unless self.op == node.op
+            return false unless self.size == node.size
             # There is no find_with_index!
             # return ! @children.find_with_index {|child,i| child != node[i] }
             @children.each_with_index do |child,i|
@@ -458,6 +539,46 @@ module LogicTools
             return true
         end
 
+        ## Tells if +self+ includes +tree+.
+        #
+        #  NOTE: * This is a tree inclusion, not a logical inclusion.
+        #        * It is assumed that the trees are sorted.
+        def include?(tree)
+            # Check from current node.
+            if self.op == tree.op and self.size >= tree.size then
+                return true unless tree.each.with_index.find do |child,i|
+                    child != @children[i]
+                end
+            end
+            # Check each child.
+            @children.each do |child|
+                return true if child.include?(tree)
+            end
+            # Do not include.
+            return false
+        end
+
+        ## Tells if +self+ covers +tree+.
+        #
+        #  NOTE: * It is assumed that the trees are sorted.
+        #        * There might still be cover even when the result is false.
+        #          For exact cover checking, please use the LogicTools::Cover
+        #          class.
+        def cover?(tree)
+            # Different operators, no probable cover.
+            return false if self.op != tree.op
+            # Check for equality with one child.
+            return true unless tree.each.with_index.find do |child,i|
+                child != @children[i]
+            end
+            # Check each child.
+            @children.each do |child|
+                return true if ( child.op == self.op and child.cover?(tree) )
+            end
+            # Do not include.
+            return false
+        end
+
         # WRONG
         ## Reduce a node: remove its redudancies using absbortion rules
         #  NOTE: NEED to CONSIDER X~X and X+~X CASES
@@ -495,28 +616,37 @@ module LogicTools
         def reduce
             # The operator used for the factors
             fop = @op == :and ? :or : :and
-            # Gather the terms converted to a sorted string for fast
-            # comparison
+            # Gather the terms to sorted nodes
             terms = @children.map do |child|
-                if (child.op == fop) then
-                    [ child, child.sort.to_s ]
-                else
-                    [ child, child.to_s ]
-                end
+                child.op == fop ? child.sort : child
             end
             nchildren = []
             # Keep only the terms that do not contain another one
+            # TODO: this loop could be faster I think...
             terms.each_with_index do |term0,i|
                 skipped = false
                 terms.each_with_index do |term1,j|
                     next if (i==j) # Same term
-                    if (term0[1].include?(term1[1])) and term0[1]!=term1[1] then
-                        # term0 contains term1 but is different, skip it
+                    # Checks the X~X or X+~X cases.
+                    if ( term0.op == :not and term0.child == term1 ) or
+                       ( term1.op == :not and term1.child == term0 ) then
+                        # Reduceable to 0 or 1
+                        return self.op == :and ? NodeFalse.new : NodeTrue.new
+                    end
+                    # Checks the covering.
+                    next if (term0.op != term1.op) # Different operators
+                    # if (term0.include?(term1) and term0 != term1) then
+                    #     # term0 contains term1 but is different, skip it
+                    #     skipped = true
+                    #     break
+                    # end
+                    if term1.cover?(term0) then
+                        # term1 covers term0 skip term0.
                         skipped = true
-                        break
+                        # break
                     end
                 end
-                nchildren << term0[0] unless skipped # Term has not been skipped
+                nchildren << term0 unless skipped # Term has not been skipped
             end
             # Avoid duplicates
             nchildren.uniq!
@@ -599,7 +729,7 @@ module LogicTools
 
         ## Duplicates the node.
         def dup # :nodoc:
-            return NodeAnd.new(@children.map(&:dup))
+            return NodeAnd.new(*@children.map(&:dup))
         end
 
         ## Computes the value of the node.
@@ -613,15 +743,13 @@ module LogicTools
         def to_sum_product(flattened = false) # :nodoc:
             # Flatten if required
             node = flattened ? self : self.flatten_deep
-            # print "node = #{node}\n"
+            return node unless node.is_parent?
             # Convert each child to sum of product
             nchildren = node.map {|child| child.to_sum_product(true) }
-            # print "nchildren = #{nchildren}\n"
             # Distribute
             while(nchildren.size>1)
                 dist = []
                 nchildren.each_slice(2) do |left,right|
-                    # print "left=#{left}, right=#{right}\n"
                     if right then
                         dist << (left.op == :or ? left.distribute(:and,right) :
                                                   right.distribute(:and,left))
@@ -629,10 +757,8 @@ module LogicTools
                         dist << left
                     end
                 end
-                # print "dist=#{dist}\n"
                 nchildren = dist
             end
-            # print "Distributed nchildren=#{nchildren}\n"
             # Generate the or
             if (nchildren.size > 1)
                 return NodeOr.new(*nchildren)
@@ -670,7 +796,7 @@ module LogicTools
 
         ## Duplicates the node.
         def dup # :nodoc:
-            return NodeOr.new(@children.map(&:dup))
+            return NodeOr.new(*@children.map(&:dup))
         end
 
         ## Computes the value of the node.
@@ -709,7 +835,13 @@ module LogicTools
             end
             @op = op.to_sym
             @child = child
-            @sym = self.to_s.to_sym
+            # @sym = self.to_s.to_sym
+            @sym = nil
+        end
+
+        ## Tells if the node is a parent.
+        def is_parent?
+            return true
         end
 
         ## Gets the number of children.
@@ -731,8 +863,8 @@ module LogicTools
         ## Gets the variables, recursively, without postprocessing.
         #
         #  Returns the variables into sets of arrays with possible doublon
-        def getVariablesRecurse() # :nodoc:
-            return @child.getVariablesRecurse
+        def get_variablesRecurse() # :nodoc:
+            return @child.get_variablesRecurse
         end
 
         ## Iterates over the children.
@@ -747,12 +879,22 @@ module LogicTools
         ## Compares with +node+.
         def ==(node) # :nodoc:
             return false unless node.is_a?(Node)
-            return false unless self.op == n.op
+            return false unless self.op == node.op
             return self.child == node.child
         end
 
+        ## Tells if the +self+ includes +tree+.
+        def include?(tree)
+            return true if self == tree # Same tree, so inclusion.
+            # Check the child
+            return true if @child.include?(tree)
+            # Do not include
+            return false
+        end
+
         ## Converts to a symbol.
         def to_sym # :nodoc:
+            @sym = self.to_s.to_sym unless @sym
             return @sym
         end
     end
@@ -805,7 +947,29 @@ module LogicTools
         #
         #  Argument +flattened+ tells if the tree is already flattend
         def to_sum_product(flattened = false) # :nodoc:
-            return NodeNot.new(@child.to_sum_product(flatten))
+            # return NodeNot.new(@child.to_sum_product(flatten))
+            # Flatten deeply if required.
+            nnode = flattened ? self : self.flatten_deep
+            if (nnode.op != :not) then
+                # Not a NOT any longer.
+                return nnode.to_sum_product
+            end
+            # Still a NOT, so apply De Morgan's law.
+            child = nnode.child
+            if child.op == :or then
+                # Can apply De Morgan's law for OR.
+                return NodeAnd.new( *child.each.map do |n|
+                    NodeNot.new(n).to_sum_product
+                end ).to_sum_product
+            elsif child.op == :and then
+                # Can apply De Morgan's law for AND.
+                return NodeOr.new( *child.each.map do |n|
+                    NodeNot.new(n).to_sum_product
+                end )
+            else
+                # Nothing to do more.
+                return nnode
+            end
         end
 
         ## Converts to a string.