sequitur 0.1.02 → 0.1.03

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTdkNzZiNTc1NjBkM2M0MDlhZDI1M2MyNTFhODJhZGI1MjFlYWI2MQ==
+    Mzg2M2MwZDY5M2M1Zjc5MGZlOWI5MTMwM2ExNTc3YWZlMWI4MjliZA==
   data.tar.gz: !binary |-
-    MmEzZGRlNTI2M2U3ZmQwYmY3MTA1MmE0MDkzMGQ0ZjBmZDJlYTRmMQ==
+    OTY4NzRlYjJmMGU1Nzc4ZDdiZmNkYWFiNzRmMWU3OThiMmExNDNkYg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MjUzMmU0YTQ4MzQ2NmVmMWU2YWQzMTkwZDNiZjM3MjgyOTFlMmRmZDJmMmJi
-    NmM5YjMxMjA0YzM5OGFiOGRiYjBmYTc2M2YyN2NiNjJiMGRlYjJkMmMxMThk
-    ZGU1MDlhYTBkZDc3YTEwMDAwNmQ0YTZlOTQyZGM5YmFmNTRjNmM=
+    Y2M3Mjg1ZTFkYzEzNWI0YWYwMmIxMGIzZGE5ZjZmZmE4NmRjMDQ3NGE3Nzhl
+    YTZiMjM1ZWM1OTRiODAwMmE0NDg0NWI1MzYyZGQ1Y2RiMTAzNWMwMzFjNzE1
+    OGVkYmNlYzBmMjlhYmI3NDZkZTZjYWNjY2VkZTk2MzQxNWQ4OGY=
   data.tar.gz: !binary |-
-    NGU2NjY2Yzc2ZmQ4NDFlN2E4MGVlYTUwMDg4NjgwYzBiYjk0ZjM5NGY4MTg4
-    NTI5NTExOTQzMWY1YzhiNWM4ZjM1OWQ5YjM1MjViZWVlYWRlMWU5NjcyNDNk
-    MzAwMzZhM2NlZGE1M2MzYTYyOGZmODkyMWE4YjA0NTE3MTk4NjA=
+    MTNiNjhlYTNhNGU1NjY4ZTUwNzkzNWRiYzllMDA5MjczYmFhMzE3MDJiZDI3
+    NWUzYzIyNTJlMDYzZTUxOWFmOTM0MzE3MDU3YTJiMTgzMTVkN2QyMGU5ZDFi
+    MmU0ZTMxZjYwMzNkZjFmNGVhMGU4M2E1ZTQ5YTliMDg4NmNlZGQ=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.03 / 2014-09-21
+* [CHANGE] Class `Sequitur::SequiturGrammar` Code refactoring: cleaner and simpler implementation the algorithm.
+* [CHANGE] Class `Sequitur::Digram`. Added new method `repeating?` that tells whether digram members are the same.
+
 ### 0.1.02 / 2014-09-18
 * [CHANGE] File `README.md`: expanded introductory text.
 * [CHANGE] File `sequitur.gemspec` : expanded gem description in the specification.

data/lib/sequitur/constants.rb

@@ -3,7 +3,7 @@
 
 module Sequitur # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.02'
+  Version = '0.1.03'
 
   # Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'

data/lib/sequitur/digram.rb

@@ -33,6 +33,11 @@ class Digram
     return key == other.key
   end
   
+  # Return true when the digram consists of twice the same symbols
+  def repeating?()
+    return symbols[0] == symbols[1]
+  end
+  
 end # class
 
 end # module

data/lib/sequitur/production.rb

@@ -54,7 +54,7 @@ class Production
   end
 
   def decr_refcount()
-    fail StandardError if @refcount == 0
+    fail StandardError, 'Internal error' if @refcount == 0
     @refcount -= 1
   end
 

data/lib/sequitur/sequitur_grammar.rb

@@ -1,13 +1,9 @@
 require_relative 'dynamic_grammar'
 
+
 module Sequitur # Module for classes implementing the Sequitur algorithm
 
 class SequiturGrammar < DynamicGrammar
-  # A hash with pairs of the form: digram key => digram
-  attr_reader(:digrams)
-
-  # The input
-  attr_reader(:parsed)
 
   # Constructor. Build the grammar from an enumerator of tokens
   def initialize(anEnum)
@@ -15,191 +11,136 @@ class SequiturGrammar < DynamicGrammar
     # Make start production compliant with utility rule
     2.times { root.incr_refcount }
 
-    @digrams = {}
-    @parsed = []
-    anEnum.each { |a_token| add_token(a_token) }
+    # Read the input sequence and apply the Sequitur algorithm
+    anEnum.each do |a_token|
+      add_token(a_token)
+      enforce_rules
+    end
   end
 
   public
 
-  # Add the given token to the grammar.
-  def add_token(aToken)
-    parsed << aToken
-    super
-  end
-
-
-  private
-
-  # Assumption: last digram of production isn't yet registered.
-  def add_production(aProduction)
-    super # Call original method from superclass...
-
-    # ... then add this behaviour
-    last_digram = aProduction.last_digram
-    digrams[last_digram.key] = last_digram
-  end
-
-  # Remove a production from the grammar
-  def remove_production(anIndex)
-    prod = productions[anIndex]
-
-    # Retrieve in the Hash all registered digrams from the removed production
-    digrams_subset = digrams.select do |_, digr|
-      digr.production == prod
-    end
 
-    # Remove them...
-    digrams_subset.each_key { |a_key| digrams.delete(a_key) }
-    super
+CollisionDiagnosis = Struct.new(:collision_found, :digram, :productions)
+
+
+  # Assuming that a new input token was added to the start production,
+  # enforce the digram unicity and rule utility rules
+  # begin
+  #   if a digram D occurs twice in the grammar then
+  #     add a production P : D (if not already there)
+  #     replace both Ds with R (reduction step).
+  #   end
+  #   if a production P : RHS in referenced only once then
+  #     replace P by its RHS (derivation step)
+  #     remove P from grammar
+  #   end
+  #  end until digram unicity and rule utility are met
+  def enforce_rules()
+    begin
+      unicity_diagnosis = detect_collision if unicity_diagnosis.nil?
+      restore_unicity(unicity_diagnosis) if unicity_diagnosis.collision_found
+      
+      useless_prod = detect_useless_production
+      restore_utility(useless_prod) if useless_prod
+
+      unicity_diagnosis = detect_collision
+      useless_prod = detect_useless_production
+      
+    end while unicity_diagnosis.collision_found || useless_prod
   end
 
-  def append_symbol_to(aProduction, aSymbol)
-    super
-
-    prod_digrams = aProduction.digrams
-    unless prod_digrams.empty?
-      last_digram = prod_digrams.last
-      matching_digram = digrams[last_digram.key]
-      if matching_digram.nil?
-        # ... No registered occurrence of the digram, then register it
-        digrams[last_digram.key] = last_digram
-      else
-        # Digram is already registered...
-        # the digram unicity rule is broken: fix this
-        preserve_unicity(aProduction)
-        enforce_rule_utility
+  # Check whether a digram is used twice in the grammar.
+  # Return an empty Hash if each digram appears once.
+  # Otherwise return a Hash with a pair of the form: digram => [Pi, Pk]
+  # Where Pi, Pk are two productions where the digram occurs.
+  def detect_collision()
+    diagnosis = CollisionDiagnosis.new(false)
+    found_so_far = {}
+    productions.each do |a_prod|
+      prod_digrams = a_prod.digrams
+      prod_digrams.each do |a_digr|
+        its_key = a_digr.key
+        if found_so_far.include? its_key
+          orig_digr = found_so_far[its_key]
+          # Disregard sequence like a a a 
+          if ((orig_digr.production == a_prod) && a_digr.repeating? &&
+            (orig_digr == a_digr))
+            next
+          end
+
+          diagnosis.digram = orig_digr
+          diagnosis.productions = [orig_digr.production, a_prod]
+          diagnosis.collision_found = true
+          break
+        else
+          found_so_far[its_key] = a_digr
+        end
       end
+      break if diagnosis.collision_found
     end
+
+    return diagnosis
   end
 
-  # The given production breaks the digram unicity rule.
-  # Fix this either by a creating a new production having the duplicate
-  # digram as its rhs or by referencing such a production.
-  # then by replacing all occurrences of the digram by reference to
-  # the fixing production.
-  # Pre-condition: the given production has a repeated digram
-  # or its last digram is used elsewhere
-  def preserve_unicity(aProduction)
-    last_digram = aProduction.last_digram
-    matching_digram = digrams[last_digram.key]
-    if aProduction == matching_digram.production
-      # Rule: no other production distinct from aProduction should have
-      # the matching digram
-      productions.each do |prod|
-        its_digrams = prod.digrams
-        its_keys = its_digrams.map(&:key)
-        next if prod == last_digram.production
-        next unless its_keys.include? last_digram.key
-        msg = "Digram #{last_digram.symbols} occurs three times!"
-        msg << "\nTwice in production #{aProduction.object_id}"
-        msg << "\nThird in production #{prod.object_id}"
-        msg << "\n#{to_string}"
-        fail StandardError, msg
+  # When a collision diagnosis indicates that a given
+  # digram d occurs twice in the grammar
+  # Then create a new production that will have
+  # the symbols of d as its rhs members.
+  def restore_unicity(aDiagnosis)
+    return if aDiagnosis.nil?
+
+    digr = aDiagnosis.digram
+    prods = aDiagnosis.productions
+    if prods.any?(&:single_digram?)
+      (simple, compound) = prods.partition do |a_prod|
+        a_prod.single_digram?
       end
-
-      # Digram appears twice in given production...
-      # Then create a new production with the digram as its rhs
+      compound[0].replace_digram(simple[0])
+    else
+      # Create a new production with the digram's symbols as its
+      # sole rhs members.
       new_prod = Production.new
-      new_prod.append_symbol(last_digram.symbols[0])
-      new_prod.append_symbol(last_digram.symbols[1])
-
-      # ... replace duplicate digram by reference to new production
-      aProduction.replace_digram(new_prod)
+      digr.symbols.each { |sym| new_prod.append_symbol(sym) }
       add_production(new_prod)
-      update_digrams_from(aProduction)
-    else
-      # Duplicate digram used in distinct production
-      # Two cases: other production is a single digram one or a multi-digram
-      other_prod = matching_digram.production
-      if other_prod.single_digram?
-        # ... replace duplicate digram by reference to other production
-        aProduction.replace_digram(other_prod)
-        update_digrams_from(aProduction)
-
-        # Special case a: replacement causes another digram duplication
-        #   in the given production
-        # Special case b: replacement causes another digram duplication
-        #   with other production
-        if aProduction.repeated_digram? ||
-          (digrams[aProduction.last_digram.key].production != aProduction)
-          preserve_unicity(aProduction)
-        end
-
+      if prods[0] == prods[1]
+        prods[0].replace_digram(new_prod)
       else
-        # aProduction, other_prod use both the same digram
-        # Then create a new production with the digram as its rhs
-        new_prod = Production.new
-        new_prod.append_symbol(last_digram.symbols[0])
-        new_prod.append_symbol(last_digram.symbols[1])
-
-        # ... replace duplicate digram by reference to new production
-        aProduction.replace_digram(new_prod)
-        other_prod.replace_digram(new_prod)
-        add_production(new_prod)
-        update_digrams_from(aProduction)
-
-        # TODO: Check when aProduction and other_prod have same preceding symbol
-        update_digrams_from(other_prod)
+        prods.each { |a_prod| a_prod.replace_digram(new_prod) }
       end
     end
   end
 
-  # Rule utility: except for the root production, every production must occur
-  # multiple times in all the rhs.
-  # Initialize occurrence hash with pairs: production id => []
-  # For each production:
-  #   - Detect occurrence of any production in the rhs
-  #   - Identify the occurring production
-  #   - In the occurrence hash push the production id of the lhs
-  # Select each production that occurs once (singleton rule):
-  # Replace the occurrence in the rhs by the rhs of the singleton rule
-  # Delete the singleton rule
-  # Update digrams
-  def enforce_rule_utility()
-    return if productions.size < 2
-
-    loop do
-      all_refcount_ok = true
-      (1...productions.size).to_a.reverse.each do |index|
-        curr_production = productions[index]
-        next unless curr_production.refcount == 1
-
-        all_refcount_ok = false
-        dependent = productions.find do |a_prod|
-          !a_prod.references_of(curr_production).empty?
-        end
-        dependent.replace_production(productions[index])
-        remove_production(index)
-        update_digrams_from(dependent)
-      end
-
-      break if all_refcount_ok
-    end
+  # Return a production that is used less than twice in the grammar.
+  def detect_useless_production()
+    useless = productions.find { |prod| prod.refcount < 2 }
+    return (useless == productions[0]) ? nil : useless
   end
 
-
-  # Update the digrams Hash with the digrams from the given production.
-  def update_digrams_from(aProduction)
-    current_digrams = aProduction.digrams
-
-    # Add new digrams only if they don't collide
-    current_digrams.each do |digr|
-      digrams[digr.key] = digr unless digrams.include? digr.key
+  # Given the passed production P is referenced only once.
+  # Then replace P by its RHS where it is referenced.
+  # And delete P
+  def restore_utility(useless_prod)
+    # Retrieve index of useless_prod
+    index =  productions.index(useless_prod)
+
+    # Retrieve production referencing useless one
+    referencing = nil
+    productions.each do |a_prod|
+      # Next line assumes non-recursive productions
+      next if a_prod == useless_prod
+
+      refs = a_prod.references_of(useless_prod)
+      next if refs.empty?
+      referencing = a_prod
+      break
     end
 
-    # Retrieve all registered digrams from the production
-    digrams_subset = digrams.select do |_, digr|
-      digr.production == aProduction
-    end
-
-    # Remove obsolete digrams
-    current_keys = current_digrams.map(&:key)
-    digrams_subset.keys.each do |a_key|
-      digrams.delete(a_key) unless current_keys.include? a_key
-    end
+    referencing.replace_production(useless_prod)
+    remove_production(index)
   end
 
+
 end # class
 
 end # module

data/spec/sequitur/digram_spec.rb

@@ -22,10 +22,18 @@ describe Digram do
       instance = Digram.new(:b, :c, production)
       expect(instance.production).to eq(production)
     end
+    
+    it 'should whether its symbols are the same' do
+       instance1 = Digram.new(:a, :a, production)
+       expect(instance1).to be_repeating
+       
+       instance1 = Digram.new(:a, :b, production)
+       expect(instance1).not_to be_repeating       
+    end
 
   end # context
 
-  context 'Standard creation & initialization:' do
+  context 'Provided services:' do
   
     it 'should compare itself to another digram' do
       instance1 = Digram.new(:a, :b, production)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.02
+  version: 0.1.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2014-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake