logic_tools 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0921177eea23a3eaec47a7c1f6f9a3885dad5759
+  data.tar.gz: c0a30c5a79a38e4113096c97398cdaf390a02b8b
+SHA512:
+  metadata.gz: 07164addc2bbf46d49af509e473e42daab575fa89a2494661d603a8b2f58389924b0b0f2753d0c09511e747d626636fb1da31a8f167b00461b360bb4a0a99288
+  data.tar.gz: 7e2de12c7322b4a8a67301839dc185e277f7984afebf7984e848da188ed5eacacc2274cae63d1a03b28a934395f6a484be1767523774ba2669f863dcd2c0cf14

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.6

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Lovic Gauthier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# LogicTools
+
+LogicTools is a set of command-line tools for processing logic expressions.
+The tools include:
+ * simplify_qm:  for simplifying a logic expression.
+ * std_conj:  for computing the conjunctive normal form of a logic expression.
+ * std_dij:   for computing the disjunctive normal form a of logic expression.
+ * truth_tbl: for generating the truth table of a logic expression.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'logic_tools'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logic_tools
+
+## Usage
+
+LogicTools is a command line-based set of tool. Each tool is used as follows:
+tool "logical expression"
+
+The logical expression is an expression where:
+* a logical variable is represented by a single alphabetical character (hence there is in total 56 possible variables);
+* a logical OR is represented by a '+' character;
+* a logical AND is represented by a '.' character (but it can be omitted);
+* a logical NOT is represented by a '~' or a '!' character;
+* opening and closing parenthesis are represented by, respectively,
+* '(' and ')' characters.
+
+Important notice: 
+* the priority among logical operators is as follows: NOT > AND > OR
+* logical expressions must be put between quotes (the '"' character).
+
+For instance the following are valid logical expression using the a,b and c variables:
+"ab+ac"
+"a.b.c"
+"a+b+!c"
+"a~(b+~c)"
+
+Finally, here are a few examples of LogicTool usage:
+* simplifying the expression a+ab:
+simplify_qm "a+ab"
+-> a
+* compute the conjunctive normal form of the expression a+ab:
+std_conj "a+ab"
+-> ab+a~b
+* compute the disjunctive normal form of the expression a+ab:
+std_conj "a+ab"
+-> (a+b)(a+~b)
+* compute the truth table of the expression a+ab:
+truth_tbl "a+ab"
+-> a b
+   0 0 0
+   0 1 0
+   1 0 1
+   1 1 1
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/civol/logic_tools.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "logic_tools"
+
+# 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

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/exe/simplify_qm

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+######################################################################
+##           Script for launching the simplify_qm.rb program        ##
+######################################################################
+
+begin
+    require 'rubygems'
+    gem 'logic_tools'
+rescue LoadError
+end
+
+load "logic_tools/simplify_qm.rb"

data/exe/std_conj

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+######################################################################
+##              Script for launching the simplify.rb program        ##
+######################################################################
+
+begin
+    require 'rubygems'
+    gem 'logic_tools'
+rescue LoadError
+end
+
+load "logic_tools/std_conj.rb"

data/exe/std_dij

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+######################################################################
+##              Script for launching the simplify.rb program        ##
+######################################################################
+
+begin
+    require 'rubygems'
+    gem 'logic_tools'
+rescue LoadError
+end
+
+load "logic_tools/std_dij.rb"

data/exe/truth_tbl

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+######################################################################
+##              Script for launching the simplify.rb program        ##
+######################################################################
+
+begin
+    require 'rubygems'
+    gem 'logic_tools'
+rescue LoadError
+end
+
+load "logic_tools/truth_tbl.rb"

data/lib/logic_tools.rb

@@ -0,0 +1,5 @@
+require "logic_tools/version"
+
+module LogicTools
+  # Your code goes here...
+end

data/lib/logic_tools/logicparse.rb

@@ -0,0 +1,91 @@
+##########################
+# Truth table generator  #
+##########################
+
+# For parsing the inputs
+require 'parslet'
+
+# For building logic tress
+require "logic_tools/logictree.rb"
+
+
+
+
+########################################################
+# Parse a string and convert to a logic tree
+
+
+module LogicTools
+
+    ## The parser of logic expressions
+    class Parser < Parslet::Parser
+
+        # True / false
+        rule(:tru) { str("1") }
+        rule(:fal) { str("0") }
+        # Variable
+        rule(:var) { match('[A-Za-uw-z]') }
+        # And operator
+        rule(:andop) { str("&&") | match('[&\.\*^]') }
+        # Or operator
+        rule(:orop) { match('[+|v]') }
+        # Not operator
+        rule(:notop) { match('[~!]') }
+
+        # Grammar rules
+        root(:expr)
+        rule(:expr) { orexpr }
+        rule(:orexpr) { (andexpr >> ( orop >> andexpr ).repeat).as(:orexpr) }
+        rule(:andexpr) { (notexpr >> ( (andop >> notexpr) | notexpr ).repeat).as(:andexpr) }
+        rule(:notexpr) { ((notop.as(:notop)).repeat >> term).as(:notexpr) }
+        rule(:term) { tru.as(:tru) | fal.as(:fal) | var.as(:var) |
+                      ( str("(") >> expr >> str(")") ) }
+    end
+
+
+    ## The logic tree generator from the syntax tree
+    class Transform < Parslet::Transform
+
+        # Terminal rules
+        rule(:tru => simple(:tru)) { NodeTrue.new() }
+        rule(:fal => simple(:fal)) { NodeFalse.new() }
+        rule(:var => simple(:var)) { NodeVar.new(var) }
+        rule(:notop => simple(:notop)) { "!" }
+
+        # Not rules
+        rule(:notexpr => simple(:expr)) { expr }
+        rule(:notexpr => sequence(:seq)) do
+            expr = seq.pop
+            if seq.size.even? then
+                expr
+            else
+                NodeNot.new(expr)
+            end
+        end
+
+        # And rules
+        rule(:andexpr => simple(:expr)) { expr }
+        rule(:andexpr => sequence(:seq)) do
+            NodeAnd.new(*seq)
+        end
+
+        # Or rules
+        rule(:orexpr => simple(:expr)) { expr }
+        rule(:orexpr => sequence(:seq)) do
+            NodeOr.new(*seq)
+        end
+    end
+
+
+    ## The parser/gerator main fuction: converts a string to a logic tree
+    #  Param:
+    #  +str+:: the string to parse
+    #  Return: the resulting logic tree
+    def string2logic(str)
+        # Remove the spaces
+        str = str.gsub(/\s+/, "")
+        # Parse the string
+        return Transform.new.apply(Parser.new.parse(str))
+    end
+
+end

data/lib/logic_tools/logicsimplify.rb

@@ -0,0 +1,384 @@
+###################################################################
+# Logic tree classes extension for simplifying a logic expression #
+# using the Quine-Mc Cluskey method                               #
+###################################################################
+
+
+require 'set'
+
+
+module LogicTools
+
+
+    ## Converts an array of variable to bit vector according to their value
+    #  @param vars the array of variables to convert
+    def vars2int(vars)
+        res = ""
+        vars.each_with_index do |var,i|
+            res[i] = var.value ? "1" : "0"
+        end
+        res
+    end
+
+
+
+
+
+    # Class describing an implicant
+    class Implicant
+        include Enumerable
+        attr_reader :mask,   # The positions of the x 
+                    :bits,   # The bit vector of the implicant
+                    :count,  # The number of 1 of the implicant
+                    :covers, # The bit values covered by the implicant
+                    :prime   # Tell if the implicant is prime or not
+        attr_accessor :var   # The variable associated with the implicant
+                             # Do not interfer at all with the class, so
+                             # public and fully accessible
+        protected
+        attr_writer :covers
+        public
+
+        ## Create an implicant
+        #  @param base if Implicant: copy constructor <br>
+        #              otherwise: creat a new implicant from a bit string
+        def initialize(base)
+            if base.is_a?(Implicant)
+                @covers = base.covers.dup
+                @bits = base.bits.dup
+                @mask = base.mask.dup
+                @count = base.count
+            else
+                @bits = base.to_s
+                unless @bits.match(/^[01]*$/)
+                    raise "Invalid bit string for an initial implicant: " + @bits
+                end
+                @mask = " " * @bits.size
+                @count = @bits.count("1")
+                @covers = [ @bits ]
+            end
+            @prime = true # By default assumed prime
+        end
+
+        ## Convert to a string
+        def to_s
+            @bits
+        end
+
+        ## inspect
+        def inspect
+            @bits.dup
+        end
+
+        ## Set the prime status
+        #  @param st the new status (true or false)
+        def prime=(st)
+            @prime = st ? true : false
+        end
+
+        ## Iterate overs the bits of the implicant
+        def each(&blk)
+            @bits.each_char(&blk)
+        end
+
+        # Compare implicants
+        # @param imp the implicant (or simply bit string) to compare with
+        def ==(imp)
+            @bits == imp.to_s
+        end
+        def <=>(imp)
+            @bits <=> imp.to_s
+        end
+
+        # duplicates the implicant
+        def dup
+            Implicant.new(self)
+        end
+
+        ## Get a bit by index
+        #  @param i the index in the bit string of the implicant
+        def [](i)
+            @bits[i]
+        end
+
+        ## Set a bit by index
+        #  @param i the index in the bit string of the implicant
+        #  @param b the bit to set
+        def []=(i,b)
+            raise "Invalid bit value: #{b}" unless ["0","1","x"].include?(b)
+            return if @bits[i] == b # Already set
+            # Update count and mask
+            @count -= 1 if @bits[i] == "1"    # One 1 less
+            @count += 1 if b == "1"           # One 1 more
+            @mask[i] = " " if @bits[i] == "x" # One x less
+            @mask[i] = "x" if b == "x"        # One x more
+            # Update the bit string
+            @bits[i] = b 
+        end
+
+
+        ## Merge with another implicant
+        #  @param imp the implicant to merge with
+        #  @return the resulting implicant
+        def merge(imp)
+            # Has imp the same mask?
+            return nil unless imp.mask == @mask
+            # First look for a 1-0 or 0-1 difference
+            found = nil
+            @bits.each_char.with_index do |b0,i|
+                b1 = imp.bits[i]
+                # Bits are different
+                if (b0 != b1) then
+                    # Stop if there where already a difference
+                    if (found)
+                        found = nil
+                        break
+                    end
+                    # A 0-1 or a 1-0 difference is found
+                    found = i
+                end
+            end
+            # Can merge at bit found
+            if found then
+                # print "merge!\n"
+                # Duplicate current implicant
+                merged = self.dup
+                # And update its x
+                merged[found] = "x"
+                # Finally update its covers
+                merged.covers = @covers | imp.covers
+                return merged
+            end
+            # No merge
+            return nil
+        end
+    end
+
+    # Class describing a group of implicants with only singletons, sortable
+    # by number of ones
+    class SameXImplicants
+        include Enumerable
+
+        ## Default constructor
+        def initialize
+            @implicants = []
+            @singletons =  Set.new # Set used for ensuring each implicant is
+                                   # present only once in the group
+        end
+
+        ## Ge the size of the group
+        def size
+            @implicants.size
+        end
+
+        ## Iterate of the implicants
+        def each(&blk)
+            @implicants.each(&blk)
+        end
+
+        ## Access by index
+        #  @param i the index
+        def [](i)
+            @implicants[i]
+        end
+
+        ## Add an implicant
+        #  @param imp the implicant to add
+        def add(imp)
+            return if @singletons.include?(imp.bits) # Implicant already present
+            @implicants << imp
+            @singletons.add(imp.bits.dup)
+        end
+        alias :<< :add
+
+        # Sort the implicants by number of ones
+        def sort!
+            @implicants.sort_by! {|imp| imp.count }
+        end
+
+        # Convert to a string
+        def to_s
+            @implicants.to_s
+        end
+        def inspect
+            to_s
+        end
+    end
+
+    ## Class describing a pseudo variable associated to an implicant
+    #  Used for the Petrick's method
+    class VarImp < Variable
+        @@base = 0 # The index of the VarImp for building the variable names
+
+        attr_reader :implicant
+
+        ## Create the variable
+        #  @param imp the implicant to create the variable from
+        def initialize(imp)
+            # Create the name of the variable
+            name = nil
+            begin
+                name = "P" + @@base.to_s
+                @@base += 1
+            end while Variable.exists?(name)
+            # Create the variable
+            super(name)
+            # Associate it with the implicant
+            @implicant = imp
+            imp.var = self
+        end
+    end
+
+
+
+    # Enhance the Node class with expression simplifying
+    class Node
+        
+        ## Generates an equivalent but simplified representation of the
+        #  function.<br>
+        #  Uses the Quine-Mc Cluskey method
+        def simplify
+            # Step 1: get the generators
+            
+            # Gather the minterms which set the function to 1 encoded as
+            # bitstrings
+            minterms = []
+            each_minterm do |vars|
+                minterms << vars2int(vars)
+            end
+
+            # print "minterms = #{minterms}\n"
+
+            # Create the implicant table
+            implicants = Hash.new {|h,k| h[k] = SameXImplicants.new }
+
+            # Convert the minterms to implicants without x
+            minterms.each do |term|
+                imp = Implicant.new(term)
+                implicants[imp.mask] << imp
+            end
+
+            # print "implicants = #{implicants}\n"
+
+            # Group the adjacent implicants to obtain the generators
+            size = 0
+            generators = []
+            # The main iterator
+            has_merged = nil
+            begin
+                has_merged = false
+                mergeds = Hash.new { |h,k| h[k] = SameXImplicants.new }
+                implicants.each_value do |group|
+                    group.sort! # Sort by number of one
+                    size = group.size
+                    # print "size = #{size}\n"
+                    group.each_with_index do |imp0,i0|
+                        # print "imp0 = #{imp0}, i0=#{i0}\n"
+                        ((i0+1)..(size-1)).each do |i1|
+                            # Get the next implicant
+                            imp1 = group[i1]
+                            # print "imp1 = #{imp1}, i1=#{i1}\n"
+                            # No need to look further if the number of 1 of imp1
+                            # is more than one larger than imp0's
+                            break if imp1.count > imp0.count+1
+                            # Try to merge
+                            mrg = imp0.merge(imp1)
+                            # print "mrg = #{mrg}\n"
+                            # Can merge
+                            if mrg then
+                                mergeds[mrg.mask] << mrg
+                                # Indicate than a merged happend
+                                has_merged = true
+                                # Mark the initial generators as not prime
+                                imp0.prime = imp1.prime = false
+                            end
+                        end 
+                        # Is the term prime?
+                        if imp0.prime then
+                            # print "imp0 is prime\n"
+                            # Yes add it to the generators
+                            generators << imp0
+                        end
+                    end
+                end
+                # print "mergeds=#{mergeds}\n"
+                # Prepare the next iteration
+                implicants = mergeds
+            end while has_merged
+
+            # 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) }
+            
+            # 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
+            # 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
+
+            # Sort by variable order
+            selected.sort_by! { |imp| imp.bits }
+
+            # print "Selected prime implicants are: #{selected}\n"
+            # Generate the resulting tree
+            variables = self.getVariables()
+            # First generate the prime implicants trees
+            selected.map! do |prime|
+                # Generate the litterals 
+                litterals = []
+                prime.each.with_index do |c,i|
+                    case c
+                    when "0" then
+                        litterals << NodeNot.new(NodeVar.new(variables[i]))
+                    when "1" then litterals << NodeVar.new(variables[i])
+                    end
+                end
+                # Generate the tree
+                NodeAnd.new(*litterals)
+            end
+            # Then generate the final sum tree
+            return NodeOr.new(*selected)
+        end
+    end
+end