falafel 0.0.2.1 → 0.0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5180f16b8868a35cf65faa396c7b341166604e2aaf7db8d9f7099c819630497f
-  data.tar.gz: 7c773f6a53d8895333d37115cba598dcf60128bff2eaf4dc47e73f7e1ca21298
+  metadata.gz: 754e7aa62a91e0f16ed875b859d8e208379df55509569dbd5d5a38e93b874fbe
+  data.tar.gz: bcbb64b7d4627514c2e3560b80e15ccc3f0dbf721448b96247188f778d8f897c
 SHA512:
-  metadata.gz: 0b7470e125d1f803eacc1d207704b90782e439fef8c7fe00dcf0acdb6c27324d24ed2da0666b3c456fe7cc7b255902002f20870e8f93d589482d4d1df3370aca
-  data.tar.gz: c8534f9da1cfec2623caa5cf0422f3d03009579374d2183a10341398a93aad87fbf2a0e85aaba0a0a766ee1d8ae62baa02e39bd2a76c7857fa6613629ae64f5a
+  metadata.gz: 8fda2266343ea3c9c919898f8ebd0381329189cf6eb08f3e281ba20e30e950d6d1bac77356ff91263c7377e77c808c1b0cb224b705dda1f3970b67b294242d9f
+  data.tar.gz: b9e9c7b8552c38d9a3f09143e68ac4cb78b5527899052a79ec975e1b6a08b45cef97158c3bc785f9f05bb1267943c38b7fc37a8575ea86ed409bd72a4f5317d8

data/lib/cfg.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'cyk'
-require_relative 'chomsky_nf'
-require_relative 'epsilon_free'
-require_relative 'chaining_free'
+require_relative 'cfg_helper/cyk'
+require_relative 'cfg_helper/chomsky_nf'
+require_relative 'cfg_helper/epsilon_free'
+require_relative 'cfg_helper/chaining_free'
 
 # Samll CFG impletation
 # Generate words and check if words are the @lang
@@ -35,26 +35,26 @@ class CFG
   end
 
   def epsilon_free(custom_rule)
-    e_free        = EpsilonFree.new
+    e_free        = CFGHelper::EpsilonFree.new
     @rules_ef_res = e_free.run custom_rule || @rules
     @rules_ef     = e_free.rebuild_rules @rules, @rules_ef_res
   end
 
   def chaining_free
-    c_free        = ChainingFree.new
+    c_free        = CFGHelper::ChainingFree.new
     @rules_cf_res = c_free.run @rules, @vars
     @rules_cf     = c_free.rebuild_rules @rules_cf_res
   end
 
   def chomsky_nf(custom_rule)
-    chomsky = ChomskyNF.new
+    chomsky = CFGHelper::ChomskyNF.new
     rules   = chomsky.run custom_rule || @rules, @alphabet
 
     @chomsky_nf_rules = chomsky.simplify rules
   end
 
   def cyk_run(word)
-    cyk = CYK.new word, @chomsky_nf_rules
+    cyk = CFGHelper::CYK.new word, @chomsky_nf_rules
 
     cyk.run
 

data/lib/cfg_helper/chaining_free.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # remove chaining rules from CFG
+  class ChainingFree
+    def run(rules, vars)
+      @rules = rules
+      @vars  = vars
+      c_r    = _chaining_relation
+
+      # build transivity relation from _chaining_relation(K) as A
+      # remove _chaining_relation from rules
+      _rebuild_rules + c_r.map { |r| _transitivity_relation r }.reduce(:concat) - c_r
+    end
+
+    def rebuild_rules(current_rules)
+      res = {}
+
+      @vars.each { |v| res[v] = [] }
+
+      current_rules.each do |l, r|
+        res[l] << r.chars unless res[l].include? r.chars
+      end
+
+      res
+    end
+
+    private
+
+    def _chaining_relation
+      rules = _rebuild_rules
+
+      rules & @vars.product(@vars)
+    end
+
+    def _rebuild_rules
+      result = []
+      @rules.each do |var, rule|
+        rule.map do |r|
+          result << [var, r.join]
+        end
+      end
+
+      result
+    end
+
+    def _transitivity_relation(pair)
+      transitive_relation = [pair]
+
+      new_pairs = []
+
+      _rebuild_rules.each do |a, b|
+        next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
+
+        new_pairs << [pair[0], b]
+      end
+
+      transitive_relation.concat new_pairs
+    end
+
+    def _new_pairs(rules)
+      rules.each do |a, b|
+        next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
+
+        new_pairs << [pair[0], b]
+      end
+    end
+  end
+end

data/lib/cfg_helper/chomsky_nf.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative 'chomsky_nf_simplifier'
+
+module CFGHelper
+  # convert to Chomsky Normal Form
+  class ChomskyNF
+    def run(rules, alphabet)
+      new_rules = {}
+      @rules    = rules
+      @alphabet = alphabet
+
+      # add cases like (A, a), (B, b)
+      _add_single_vars new_rules
+
+      # change rules like (X, aX) to (X, AX)
+      _handle_simple_rule new_rules
+
+      _handle_all_rule new_rules
+    end
+
+    def simplify(rules)
+      simplifier = CFGHelper::ChomskyNFSimplifier.new
+
+      simplifier.run rules, @alphabet
+    end
+
+    private
+
+    def _add_single_vars(new_rules)
+      @rules.values.reduce(:concat).each do |rule|
+        rule.select { |var| var == var.downcase }.each do |r|
+          new_rules[r.upcase] = r
+        end
+      end
+    end
+
+    def _handle_simple_rule(new_rules)
+      @rules.each do |var, rule|
+        new_rules[var] = []
+        rule.each do |r|
+          next if r.empty?
+
+          new_rules[var] << r.map(&:upcase)
+        end
+      end
+    end
+
+    def _handle_all_rule(new_rules)
+      new_rules_buffer = []
+
+      new_rules.each do |var, rules|
+        next if _is_character? rules
+
+        new_rules_buffer << _new_rules_buffer(rules, var)
+      end
+
+      new_rules.merge! new_rules_buffer.reduce(&:merge)
+    end
+
+    def _is_character?(value)
+      value.is_a?(String) && value.length == 1
+    end
+
+    def _new_rules_buffer(rules, var)
+      helper_vars = _helper_vars rules
+      helper_vars.merge! @alphabet.each_with_object({}) { |ele, meme| meme[ele.capitalize] = ele.capitalize }
+
+      _new_rules rules, var, helper_vars
+    end
+
+    def _check_simplify(rule, holder, current_var)
+      return false unless rule.size == 1
+
+      holder[current_var] << rule.last unless holder[current_var].include? rule
+
+      true
+    end
+
+    def _new_rules(rules, var, helper_vars)
+      holder = {}
+
+      rules.each do |rule|
+        rest = ''
+        rule.each_with_index do |head, index|
+          current_var = index.zero? ? var : rest
+          holder[current_var] ||= []
+
+          is_simple = _check_simplify rule, holder, current_var
+
+          break if is_simple
+
+          rest = _chomsky_nf_vars index, rule, helper_vars
+
+          nf_rest = "#{head}#{rest}"
+
+          if index + 2 == rule.size
+            if rest.nil?
+              rest     = rule.last
+              nf_rest += rest
+            end
+
+            holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
+
+            break
+          else
+            holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
+          end
+        end
+      end
+
+      holder
+    end
+
+    def _chomsky_nf_vars(index, rule, helper_vars)
+      rule_size = rule.size
+      rest      = rule[(index + 1)..rule_size].join
+
+      helper_vars.key(rest)
+    end
+
+    def _helper_vars(rules)
+      helper_vars = {}
+
+      rules.each do |rule|
+        rule.each_with_index do |_, index|
+          letter, rest = _chomsky_nf_helper_vars index, rule, helper_vars.keys
+
+          break if index + 2 == rule.size
+
+          next if helper_vars.values.include? rest
+
+          helper_vars[letter] = rest unless helper_vars.key?(letter) && rest.size > 1
+        end
+      end
+
+      helper_vars
+    end
+
+    def _chomsky_nf_helper_vars(index, rule, helper_vars)
+      rule_size   = rule.size
+      letter      = helper_vars.empty? ? _find_letter(index) : helper_vars.sort!.last.succ
+      rest        = rule[(index + 1)..rule_size].join
+
+      [letter, rest]
+    end
+
+    def _find_letter(n)
+      result = 'H'
+      n.times { result = result.succ }
+
+      result
+    end
+  end
+end

data/lib/cfg_helper/chomsky_nf_simplifier.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # simplify chomsky normal form
+  class ChomskyNFSimplifier
+    def run(new_rules, alphabet)
+      vars_with_one_letter = _vars_with_one_letter new_rules, alphabet
+
+      return new_rules if vars_with_one_letter.empty?
+
+      extendible_rules = _find_extendible_rules new_rules, vars_with_one_letter.keys
+
+      return new_rules if extendible_rules.empty?
+
+      missing_rules = _missing_rules extendible_rules, vars_with_one_letter
+
+      _add_missing_rules missing_rules, new_rules
+
+      new_rules
+    end
+
+    private
+
+    def _vars_with_one_letter(new_rules, alphabet)
+      vars = {}
+
+      new_rules.each do |key, values|
+        # skip simple rules like (A, a), (B, b),...
+        next if values.size == 1
+
+        letters   = values.select { |val| _is_letter val, alphabet }.uniq
+        vars[key] = letters
+      end
+
+      vars
+    end
+
+    def _is_letter(val, alphabet)
+      val.size == 1 && alphabet.include?(val.downcase)
+    end
+
+    def _find_extendible_rules(new_rules, rules_keys)
+      extendible = {}
+
+      filterd_rules = new_rules.reject { |_, rules| rules.is_a?(String) }
+
+      filterd_rules.each do |letter, rules|
+        rules_keys.each do |rules_key|
+          rules.each do |rule|
+            next unless rule.include?(rules_key)
+
+            extendible[letter] ||= []
+            extendible[letter] << rule
+          end
+        end
+      end
+
+      extendible
+    end
+
+    def _missing_rules(extendible_rules, vars)
+      res = {}
+
+      extendible_rules.each do |var_rule, nfs|
+        nfs.each do |nf|
+          vars.each do |match_char, replacement_chars|
+            replacement_chars.each do |rc|
+              res[var_rule] ||= []
+              res[var_rule] << _combinations(nf, rc, match_char)
+            end
+          end
+
+          res[var_rule] = res[var_rule]&.flatten&.uniq
+
+          _check_special_case nf, res, var_rule, vars
+        end
+      end
+
+      res
+    end
+
+    def _combinations(original_string, replacement_char, match_char)
+      combinations = []
+
+      0.upto(1) do |i|
+        0.upto(1) do |j|
+          new_rule = original_string.dup
+          new_rule[0] = replacement_char if i == 1 && original_string[0] == match_char
+          new_rule[1] = replacement_char if j == 1 && original_string[1] == match_char
+          combinations << new_rule
+        end
+      end
+
+      combinations.uniq
+    end
+
+    def _add_missing_rules(missing_rules, new_rules)
+      missing_rules.each do |key, val|
+        next if val.nil?
+
+        new_rules[key].concat(val).uniq!
+      end
+    end
+
+    def _check_special_case(nf, res, var_rule, vars)
+      vars.each do |match_char, combi|
+        next unless nf == match_char * 2
+
+        missing_rules = combi.map { |lft| combi.map { |rgt| "#{lft}#{rgt}" } }.flatten
+
+        res[var_rule].concat(missing_rules)
+      end
+
+      res
+    end
+  end
+end

data/lib/cfg_helper/cyk.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # Implemention of cyk algo.
+  class CYK
+    attr_reader :matrix, :is_in_l
+
+    def initialize(word, custom_rule)
+      @word        = word
+      @rules       = custom_rule.select { |_, val| val.is_a?(Array) }
+      @helper_vars = @rules.values.flatten
+    end
+
+    def run
+      _cyk_fill_diagonal
+      _cyk_fill_matrix
+      @is_in_l = _is_in_l?
+    end
+
+    private
+
+    def _cyk_fill_diagonal
+      wrd_lng = @word.length
+      @matrix = wrd_lng.times.map { wrd_lng.times.map { [] } }
+
+      (0..wrd_lng - 1).each do |index|
+        @matrix[index][index] = @word[index].upcase
+      end
+    end
+
+    def _cyk_fill_matrix
+      @matrix.size.times do |limiter|
+        (0...@matrix.length - limiter).each do |i|
+          j = i + limiter
+
+          next if i == j
+
+          helper_var      = _helper_var i, j
+          matrix_ele_info = _matrix_ele_info i, j
+          @matrix[i][j]   = _add_to_matrix helper_var, matrix_ele_info
+        end
+      end
+    end
+
+    def _helper_var(row, col)
+      res = '0'
+
+      (row..col - 1).step(1) do |h|
+        p_  = @matrix[row][h]
+        q_  = @matrix[h + 1][col]
+        res = "#{p_}#{q_}"
+
+        break if @helper_vars.include? res
+      end
+
+      res
+    end
+
+    def _matrix_ele_info(i, j)
+      res = {}
+
+      res['i'] = i
+      res['j'] = j
+      res['row_c'] = @matrix.count
+
+      res
+    end
+
+    def _add_to_matrix(helper_var, matrix_ele_info)
+      matrix_ele = '0'
+      return if helper_var == matrix_ele
+
+      keys = []
+
+      @rules.each do |key, vals|
+        vals.each do |val|
+          keys << key if val == helper_var
+        end
+      end
+
+      _matrix_ele keys, matrix_ele_info
+    end
+
+    def _matrix_ele(keys, matrix_ele_info)
+      return 'S' if keys.include?('S') && _is_last_element?(matrix_ele_info)
+
+      return keys.last if keys.size == 1
+
+      keys.reject { |key| key == 'S' }.last || '0'
+    end
+
+    def _is_last_element?(matrix_ele_info)
+      matrix_ele_info['i'].zero? && matrix_ele_info['j'] == matrix_ele_info['row_c'] - 1
+    end
+
+    def _is_in_l?
+      @matrix.first.last == 'S'
+    end
+  end
+end

data/lib/cfg_helper/epsilon_free.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module CFGHelper
+  # used to clear a CFG from the epsilon rules
+  class EpsilonFree
+    def run(rules)
+      epsilon  = _epsilon rules
+      rules_ef = {}
+
+      return if epsilon.empty?
+
+      epsilon.each do |e_class|
+        cleared_rules     = _cleared_rules rules[e_class]
+        epsilon_free_word = cleared_rules.map(&:join)
+        grammer           = _grammer_epsilon_free epsilon_free_word, e_class
+        rules_ef[e_class] = grammer
+      end
+
+      rules_ef
+    end
+
+    def rebuild_rules(current_rules, rules_epsilon_free)
+      missing_vars = current_rules.keys - rules_epsilon_free.keys
+
+      res = {}
+      rules_epsilon_free.each do |key, rules|
+        res[key] = []
+        rules.each do |rule|
+          res[key] << rule.chars
+        end
+      end
+
+      missing_vars.each { |v| res[v] = current_rules[v] }
+
+      res
+    end
+
+    private
+
+    def _epsilon(rules)
+      res = rules.map do |var, rule|
+        next unless rule.include? []
+
+        var
+      end
+      res.reject(&:nil?)
+    end
+
+    def _cleared_rules(rules)
+      rules.reject(&:empty?)
+    end
+
+    def _grammer_epsilon_free(epsilon_free_word, e_class)
+      rules_epsilon_location = _new_rules_epsilon_location epsilon_free_word, e_class
+
+      res = []
+      rules_epsilon_location.map do |rule, possibilities|
+        possibilities.each do |possibility|
+          res << _remove_e_class(possibility, rule.split(''))
+        end
+
+        res << epsilon_free_word.delete(e_class) if possibilities.size == 1
+      end
+
+      res.uniq.reject(&:nil?)
+    end
+
+    def _new_rules_epsilon_location(s_rule, e_class)
+      res = {}
+      s_rule.each do |rule|
+        s_index = []
+        rule.each_char.with_index { |char, index| s_index << index if char == e_class }
+        res[rule] = _power_set(s_index)
+      end
+
+      res
+    end
+
+    def _power_set(set)
+      if set.empty?
+        [[]]
+      else
+        element = set[0]
+        subsets = _power_set set[1..]
+        subsets + subsets.map { |subset| [element] + subset }
+      end
+    end
+
+    def _remove_e_class(possibility, cleared_rules)
+      return cleared_rules.join '' if possibility.empty?
+
+      new_rule = cleared_rules.join ''
+      possibility.reverse.each { |index| new_rule.slice! index }
+
+      new_rule
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: falafel
 version: !ruby/object:Gem::Version
-  version: 0.0.2.1
+  version: 0.0.2.2
 platform: ruby
 authors:
 - Abed Alkedda
@@ -17,12 +17,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cfg.rb
-- lib/chaining_free.rb
-- lib/chomsky_nf.rb
-- lib/chomsky_nf_simplifier.rb
-- lib/cyk.rb
+- lib/cfg_helper/chaining_free.rb
+- lib/cfg_helper/chomsky_nf.rb
+- lib/cfg_helper/chomsky_nf_simplifier.rb
+- lib/cfg_helper/cyk.rb
+- lib/cfg_helper/epsilon_free.rb
 - lib/dfa.rb
-- lib/epsilon_free.rb
 - lib/falafel.rb
 - lib/pump.rb
 - lib/rx.rb

data/lib/chaining_free.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-# remove chaining rules from CFG
-class ChainingFree
-  def run(rules, vars)
-    @rules = rules
-    @vars  = vars
-    c_r    = _chaining_relation
-
-    # build transivity relation from _chaining_relation(K) as A
-    # remove _chaining_relation from rules
-    _rebuild_rules + c_r.map { |r| _transitivity_relation r }.reduce(:concat) - c_r
-  end
-
-  def rebuild_rules(current_rules)
-    res = {}
-
-    @vars.each { |v| res[v] = [] }
-
-    current_rules.each do |l, r|
-      res[l] << r.chars unless res[l].include? r.chars
-    end
-
-    res
-  end
-
-  private
-
-  def _chaining_relation
-    rules = _rebuild_rules
-
-    rules & @vars.product(@vars)
-  end
-
-  def _rebuild_rules
-    result = []
-    @rules.each do |var, rule|
-      rule.map do |r|
-        result << [var, r.join]
-      end
-    end
-
-    result
-  end
-
-  def _transitivity_relation(pair)
-    transitive_relation = [pair]
-
-    new_pairs = []
-
-    _rebuild_rules.each do |a, b|
-      next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
-
-      new_pairs << [pair[0], b]
-    end
-
-    transitive_relation.concat new_pairs
-  end
-
-  def _new_pairs(rules)
-    rules.each do |a, b|
-      next unless pair[1] == a && !transitive_relation.include?([pair[0], b])
-
-      new_pairs << [pair[0], b]
-    end
-  end
-end

data/lib/chomsky_nf.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'chomsky_nf_simplifier'
-
-# convert to Chomsky Normal Form
-class ChomskyNF
-  def run(rules, alphabet)
-    new_rules = {}
-    @rules    = rules
-    @alphabet = alphabet
-
-    # add cases like (A, a), (B, b)
-    _add_single_vars new_rules
-
-    # change rules like (X, aX) to (X, AX)
-    _handle_simple_rule new_rules
-
-    _handle_all_rule new_rules
-  end
-
-  def simplify(rules)
-    simplifier = ChomskyNFSimplifier.new
-
-    simplifier.run rules, @alphabet
-  end
-
-  private
-
-  def _add_single_vars(new_rules)
-    @rules.values.reduce(:concat).each do |rule|
-      rule.select { |var| var == var.downcase }.each do |r|
-        new_rules[r.upcase] = r
-      end
-    end
-  end
-
-  def _handle_simple_rule(new_rules)
-    @rules.each do |var, rule|
-      new_rules[var] = []
-      rule.each do |r|
-        next if r.empty?
-
-        new_rules[var] << r.map(&:upcase)
-      end
-    end
-  end
-
-  def _handle_all_rule(new_rules)
-    new_rules_buffer = []
-
-    new_rules.each do |var, rules|
-      next if _is_character? rules
-
-      new_rules_buffer << _new_rules_buffer(rules, var)
-    end
-
-    new_rules.merge! new_rules_buffer.reduce(&:merge)
-  end
-
-  def _is_character?(value)
-    value.is_a?(String) && value.length == 1
-  end
-
-  def _new_rules_buffer(rules, var)
-    helper_vars = _helper_vars rules
-    helper_vars.merge! @alphabet.each_with_object({}) { |ele, meme| meme[ele.capitalize] = ele.capitalize }
-
-    _new_rules rules, var, helper_vars
-  end
-
-  def _check_simplify(rule, holder, current_var)
-    return false unless rule.size == 1
-
-    holder[current_var] << rule.last unless holder[current_var].include? rule
-
-    true
-  end
-
-  def _new_rules(rules, var, helper_vars)
-    holder = {}
-
-    rules.each do |rule|
-      rest = ''
-      rule.each_with_index do |head, index|
-        current_var = index.zero? ? var : rest
-        holder[current_var] ||= []
-
-        is_simple = _check_simplify rule, holder, current_var
-
-        break if is_simple
-
-        rest = _chomsky_nf_vars index, rule, helper_vars
-
-        nf_rest = "#{head}#{rest}"
-
-        if index + 2 == rule.size
-          if rest.nil?
-            rest     = rule.last
-            nf_rest += rest
-          end
-
-          holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
-
-          break
-        else
-          holder[current_var] << nf_rest unless holder[current_var].include? nf_rest
-        end
-      end
-    end
-
-    holder
-  end
-
-  def _chomsky_nf_vars(index, rule, helper_vars)
-    rule_size = rule.size
-    rest      = rule[(index + 1)..rule_size].join
-
-    helper_vars.key(rest)
-  end
-
-  def _helper_vars(rules)
-    helper_vars = {}
-
-    rules.each do |rule|
-      rule.each_with_index do |_, index|
-        letter, rest = _chomsky_nf_helper_vars index, rule, helper_vars.keys
-
-        break if index + 2 == rule.size
-
-        next if helper_vars.values.include? rest
-
-        helper_vars[letter] = rest unless helper_vars.key?(letter) && rest.size > 1
-      end
-    end
-
-    helper_vars
-  end
-
-  def _chomsky_nf_helper_vars(index, rule, helper_vars)
-    rule_size   = rule.size
-    letter      = helper_vars.empty? ? _find_letter(index) : helper_vars.sort!.last.succ
-    rest        = rule[(index + 1)..rule_size].join
-
-    [letter, rest]
-  end
-
-  def _find_letter(n)
-    result = 'H'
-    n.times { result = result.succ }
-
-    result
-  end
-end

data/lib/chomsky_nf_simplifier.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# simplify chomsky normal form
-class ChomskyNFSimplifier
-  def run(new_rules, alphabet)
-    vars_with_one_letter = _vars_with_one_letter new_rules, alphabet
-
-    return new_rules if vars_with_one_letter.empty?
-
-    extendible_rules = _find_extendible_rules new_rules, vars_with_one_letter.keys
-
-    return new_rules if extendible_rules.empty?
-
-    missing_rules = _missing_rules extendible_rules, vars_with_one_letter
-
-    _add_missing_rules missing_rules, new_rules
-
-    new_rules
-  end
-
-  private
-
-  def _vars_with_one_letter(new_rules, alphabet)
-    vars = {}
-
-    new_rules.each do |key, values|
-      # skip simple rules like (A, a), (B, b),...
-      next if values.size == 1
-
-      letters   = values.select { |val| _is_letter val, alphabet }.uniq
-      vars[key] = letters
-    end
-
-    vars
-  end
-
-  def _is_letter(val, alphabet)
-    val.size == 1 && alphabet.include?(val.downcase)
-  end
-
-  def _find_extendible_rules(new_rules, rules_keys)
-    extendible = {}
-
-    filterd_rules = new_rules.reject { |_, rules| rules.is_a?(String) }
-
-    filterd_rules.each do |letter, rules|
-      rules_keys.each do |rules_key|
-        rules.each do |rule|
-          next unless rule.include?(rules_key)
-
-          extendible[letter] ||= []
-          extendible[letter] << rule
-        end
-      end
-    end
-
-    extendible
-  end
-
-  def _missing_rules(extendible_rules, vars)
-    res = {}
-
-    extendible_rules.each do |var_rule, nfs|
-      nfs.each do |nf|
-        vars.each do |match_char, replacement_chars|
-          replacement_chars.each do |rc|
-            res[var_rule] ||= []
-            res[var_rule] << _combinations(nf, rc, match_char)
-          end
-        end
-
-        res[var_rule] = res[var_rule]&.flatten&.uniq
-
-        _check_special_case nf, res, var_rule, vars
-      end
-    end
-
-    res
-  end
-
-  def _combinations(original_string, replacement_char, match_char)
-    combinations = []
-
-    0.upto(1) do |i|
-      0.upto(1) do |j|
-        new_rule = original_string.dup
-        new_rule[0] = replacement_char if i == 1 && original_string[0] == match_char
-        new_rule[1] = replacement_char if j == 1 && original_string[1] == match_char
-        combinations << new_rule
-      end
-    end
-
-    combinations.uniq
-  end
-
-  def _add_missing_rules(missing_rules, new_rules)
-    missing_rules.each do |key, val|
-      next if val.nil?
-
-      new_rules[key].concat(val).uniq!
-    end
-  end
-
-  def _check_special_case(nf, res, var_rule, vars)
-    vars.each do |match_char, combi|
-      next unless nf == match_char * 2
-
-      missing_rules = combi.map { |lft| combi.map { |rgt| "#{lft}#{rgt}" } }.flatten
-
-      res[var_rule].concat(missing_rules)
-    end
-
-    res
-  end
-end

data/lib/cyk.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-# Implemention of cyk algo.
-class CYK
-  attr_reader :matrix, :is_in_l
-
-  def initialize(word, custom_rule)
-    @word        = word
-    @rules       = custom_rule.select { |_, val| val.is_a?(Array) }
-    @helper_vars = @rules.values.flatten
-  end
-
-  def run
-    _cyk_fill_diagonal
-    _cyk_fill_matrix
-    @is_in_l = _is_in_l?
-  end
-
-  private
-
-  def _cyk_fill_diagonal
-    wrd_lng = @word.length
-    @matrix = wrd_lng.times.map { wrd_lng.times.map { [] } }
-
-    (0..wrd_lng - 1).each do |index|
-      @matrix[index][index] = @word[index].upcase
-    end
-  end
-
-  def _cyk_fill_matrix
-    @matrix.size.times do |limiter|
-      (0...@matrix.length - limiter).each do |i|
-        j = i + limiter
-
-        next if i == j
-
-        helper_var      = _helper_var i, j
-        matrix_ele_info = _matrix_ele_info i, j
-        @matrix[i][j]   = _add_to_matrix helper_var, matrix_ele_info
-      end
-    end
-  end
-
-  def _helper_var(row, col)
-    res = '0'
-
-    (row..col - 1).step(1) do |h|
-      p_  = @matrix[row][h]
-      q_  = @matrix[h + 1][col]
-      res = "#{p_}#{q_}"
-
-      break if @helper_vars.include? res
-    end
-
-    res
-  end
-
-  def _matrix_ele_info(i, j)
-    res = {}
-
-    res['i'] = i
-    res['j'] = j
-    res['row_c'] = @matrix.count
-
-    res
-  end
-
-  def _add_to_matrix(helper_var, matrix_ele_info)
-    matrix_ele = '0'
-    return if helper_var == matrix_ele
-
-    keys = []
-
-    @rules.each do |key, vals|
-      vals.each do |val|
-        keys << key if val == helper_var
-      end
-    end
-
-    _matrix_ele keys, matrix_ele_info
-  end
-
-  def _matrix_ele(keys, matrix_ele_info)
-    return 'S' if keys.include?('S') && _is_last_element?(matrix_ele_info)
-
-    return keys.last if keys.size == 1
-
-    keys.reject { |key| key == 'S' }.last || '0'
-  end
-
-  def _is_last_element?(matrix_ele_info)
-    matrix_ele_info['i'].zero? && matrix_ele_info['j'] == matrix_ele_info['row_c'] - 1
-  end
-
-  def _is_in_l?
-    @matrix.first.last == 'S'
-  end
-end

data/lib/epsilon_free.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# used to clear a CFG from the epsilon rules
-class EpsilonFree
-  def run(rules)
-    epsilon  = _epsilon rules
-    rules_ef = {}
-
-    return if epsilon.empty?
-
-    epsilon.each do |e_class|
-      cleared_rules     = _cleared_rules rules[e_class]
-      epsilon_free_word = cleared_rules.map(&:join)
-      grammer           = _grammer_epsilon_free epsilon_free_word, e_class
-      rules_ef[e_class] = grammer
-    end
-
-    rules_ef
-  end
-
-  def rebuild_rules(current_rules, rules_epsilon_free)
-    missing_vars = current_rules.keys - rules_epsilon_free.keys
-
-    res = {}
-    rules_epsilon_free.each do |key, rules|
-      res[key] = []
-      rules.each do |rule|
-        res[key] << rule.chars
-      end
-    end
-
-    missing_vars.each { |v| res[v] = current_rules[v] }
-
-    res
-  end
-
-  private
-
-  def _epsilon(rules)
-    res = rules.map do |var, rule|
-      next unless rule.include? []
-
-      var
-    end
-    res.reject(&:nil?)
-  end
-
-  def _cleared_rules(rules)
-    rules.reject(&:empty?)
-  end
-
-  def _grammer_epsilon_free(epsilon_free_word, e_class)
-    rules_epsilon_location = _new_rules_epsilon_location epsilon_free_word, e_class
-
-    res = []
-    rules_epsilon_location.map do |rule, possibilities|
-      possibilities.each do |possibility|
-        res << _remove_e_class(possibility, rule.split(''))
-      end
-
-      res << epsilon_free_word.delete(e_class) if possibilities.size == 1
-    end
-
-    res.uniq.reject(&:nil?)
-  end
-
-  def _new_rules_epsilon_location(s_rule, e_class)
-    res = {}
-    s_rule.each do |rule|
-      s_index = []
-      rule.each_char.with_index { |char, index| s_index << index if char == e_class }
-      res[rule] = _power_set(s_index)
-    end
-
-    res
-  end
-
-  def _power_set(set)
-    if set.empty?
-      [[]]
-    else
-      element = set[0]
-      subsets = _power_set set[1..]
-      subsets + subsets.map { |subset| [element] + subset }
-    end
-  end
-
-  def _remove_e_class(possibility, cleared_rules)
-    return cleared_rules.join '' if possibility.empty?
-
-    new_rule = cleared_rules.join ''
-    possibility.reverse.each { |index| new_rule.slice! index }
-
-    new_rule
-  end
-end