evoc 3.6.2 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8945b15a68ce28d5c3c9e8b10b2478f3fcbb139f
-  data.tar.gz: 597aaf2639f69c61788312c030c76706e419b0bf
+  metadata.gz: 2b867c7a5e05b3c2be58b9dd361554a43f3f277c
+  data.tar.gz: 9d00091a6fd7685f048930889aaf252df5aa6634
 SHA512:
-  metadata.gz: 804e7b6ec7b27c35b09697a44f5f20895efe94a31631c8068ba83861d69856e948820056b22571b10bd47ce09a2104dd73f21cd18df0bf49619df23813425d61
-  data.tar.gz: 9ad3251c853afb583f0f257cec83cb09959aab339140cea5a7c032d48ff7e023a80f8239ae6b269d0357aafa0e8757c6912f6814fe8b85e51e285dd85e83e44d
+  metadata.gz: f89dbef20f735e0f8c6b8f7104ea8b38a4dd118707089b17acdf529591fd652478406047cb5d4b08e18afb746d3edf46dc7cf9ac7eb208d214f91e9050841c12
+  data.tar.gz: 7e1955af5653df5d7afd986e9d522178b32d10c26771833e4d37aec910dd93208de56c8a6f83bd21faeb8796b098da808f72a05c9f6e3caf1100064fd20d7bb0

data/.gitignore

@@ -13,3 +13,5 @@ evoc.log
 /.history
 /GRTAGS
 *TAGS
+*~
+*#

data/evoc.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ruby-progressbar"
   spec.add_runtime_dependency "rubyzip"
   spec.add_runtime_dependency "algorithms"
+  spec.add_runtime_dependency "rubytree"
 end

data/lib/evoc/algorithm.rb

@@ -20,8 +20,8 @@ module Evoc
               Evoc::Algorithm.cached_rule_range(match[:min].to_i,match[:max].to_i,tx_store:tx_store,query:query)
             elsif match = /rule_range_(?<min>\d+)_(?<max>\d+)/.match(algorithm)
               Evoc::Algorithm.rule_range(match[:min].to_i,match[:max].to_i,tx_store:tx_store,query:query)
-            elsif Evoc::Algorithm.respond_to?(algorithm+'_algorithm')
-                Evoc::Algorithm.method(algorithm+'_algorithm').call(tx_store:tx_store,query:query)
+            elsif Evoc::Algorithm.respond_to?(algorithm)
+                Evoc::Algorithm.method(algorithm).call(tx_store:tx_store,query:query)
             else raise ArgumentError.new, "#{algorithm} is not an available algorithm"
             end
         end
@@ -105,6 +105,70 @@ module Evoc
         end
 
 
+        def self.not_subsumed(tx_store:, query:)
+          #initial filter, we consider all txes where something in the query changed
+          query_changed_in = tx_store.transactions_of_list(query)
+          # now find what subsets of the query changed in each tx
+          trie = Containers::Trie.new
+          query_changed_in.each do |tx_id|
+            tx = tx_store.get_tx(id:tx_id,id_type: :index)
+            antecedent = (query & tx.items)
+            consequents = (tx.items - antecedent)
+            if consequents.size != 0
+              consequents.each do |consequent|
+                entry = "#{consequent.to_s}#{antecedent.join('')}"
+                if trie.get(entry).nil?
+                  puts "ADDED #{entry}"
+                  trie.push(entry,consequent.to_s)
+                end
+              end
+            end
+          end
+          return trie
+          # now generate rules 
+          # rule_store = Evoc::RuleStore.new(query: query)
+          # rules.each do |consequent,antecedents|
+          #   antecedents.each do |antecedent|
+          #     rule_store << Evoc::Rule.new(lhs: antecedent,rhs: consequent,tx_store:tx_store)
+          #   end
+          # end
+          # return rule_store
+        end
+
+        ##
+        # Find the largest rules for each unique consequent
+        def self.largest_rules(tx_store:,query:)
+          #initial filter, we consider all txes where something in the query changed
+          query_changed_in = tx_store.transactions_of_list(query)
+          # now find what subsets of the query changed in each tx
+          rules = Hash.new
+          query_changed_in.each do |tx_id|
+            tx = tx_store.get_tx(id:tx_id,id_type: :index)
+            antecedent = (query & tx.items)
+            consequents = (tx.items - antecedent)
+            if consequents.size != 0
+              consequents.each do |consequent|
+                if rules[consequent].nil?
+                  rules[consequent] = Set.new([antecedent])             # new consequent
+                elsif antecedent.size > rules[consequent].first.size   # larger antecedent
+                  rules[consequent] = Set.new([antecedent])
+                elsif antecedent.size == rules[consequent].first.size  # equally large antecedent
+                  rules[consequent] << antecedent
+                end
+              end
+            end
+          end
+          # now generate rules 
+          rule_store = Evoc::RuleStore.new(query: query)
+          rules.each do |consequent,antecedents|
+            antecedents.each do |antecedent|
+              rule_store << Evoc::Rule.new(lhs: antecedent,rhs: consequent,tx_store:tx_store)
+            end
+          end
+          return rule_store
+        end
+
+
         ##
         # TARMAQ
         # find largest subsets in @query with evidence in @tx_store version
@@ -113,7 +177,6 @@ module Evoc
             #initial filter, we consider all txes where something in the query changed
             query_changed_in = tx_store.transactions_of_list(query)
             # now find what subsets of the query changed in each tx
-            rules = Hash.new
             query_changed_in.each do |tx_id|
                 tx = tx_store.get_tx(id:tx_id,id_type: :index)
                 largest_match_in_query = (query & tx.items)
@@ -134,14 +197,18 @@ module Evoc
         ###
         ## rose
         ###
-        def self.rose_algorithm(tx_store:,query:)
+        def self.rose(tx_store:,query:)
           qs = query.size
           self.cached_rule_range(qs,qs,tx_store: tx_store, query: query)
         end
 
-        def self.co_change_algorithm(tx_store:, query:)
+        def self.co_change(tx_store:, query:)
           self.cached_rule_range(1,1,tx_store: tx_store, query: query)
         end
 
+        def self.closed_rules(tx_store:, query:)
+          Evoc::ClosedRules.closed_rules(tx_store: tx_store,query: query)
+        end
+
     end # Algorithm
 end

data/lib/evoc/algorithms/closed_rules.rb

@@ -0,0 +1,145 @@
+module Evoc
+  class ClosedRules
+    def self.closed_rules(tx_store:,query:)
+      # @@store = tx_store
+      # create initial trees, one tree per consequent
+      tree = self.initialize_tree(tx_store,query)
+      # puts "INIT TREE:"
+      # tree.print_tree(1,nil,lambda {|node,pre| puts "#{pre} #{@@store.ints2names(node.name.map(&:to_i))}"})
+      closed_rules = Evoc::RuleStore.new(query: query)
+      tree.children.each do |consequent|
+        self.extend_nodes(consequent).each do |frequency, closed_sets|
+          closed_sets.each do |closed_set| 
+            antecedent = closed_set - consequent.name
+            closed_rules << Evoc::Rule.new(lhs: antecedent.map(&:to_i), rhs: consequent.name.map(&:to_i),tx_store: tx_store, m_support: frequency.to_r/tx_store.size)
+          end
+        end
+      end
+      return closed_rules
+    end
+
+    private
+    def self.initialize_tree(tx_store, query)
+      tree = Tree::TreeNode.new([])
+      # find all items that changed with something in the query
+      query_changed_in = tx_store.transactions_of_list(query)
+      # store all items from the query that have changed with each consequent
+      query_changed_in.each do |tx_id|
+        tx = tx_store.get_tx(id:tx_id,id_type: :index)
+        antecedent = (query & tx.items)
+        consequents = (tx.items - antecedent)
+        if consequents.size != 0
+          consequents.each do |consequent|
+            consequent_key = [consequent.to_s]
+            if tree[consequent_key].nil?
+              # initialize candidates
+              tree << Tree::TreeNode.new([consequent.to_s],tx_store.transactions_of(consequent))
+            end
+            txes_consequent = tree[consequent_key].content
+            antecedent.each do |item|
+              union = [item.to_s,consequent.to_s]
+              if tree[consequent_key][union].nil?
+                txes_union = tx_store.transactions_of(item) & txes_consequent
+                tree[consequent_key] << Tree::TreeNode.new(union,txes_union)
+              end
+            end
+          end
+        end
+      end
+      return(tree)
+    end
+
+    def self.extend_nodes(root,closed_rules: {})
+      current_node = root.first_child
+      while(!current_node.nil?) do
+        a = current_node
+        b = a.next_sibling
+        while(!b.nil?) do
+          # print "Checking #{@@store.ints2names(a.name.map(&:to_i))}:{#{a.content}} against #{@@store.ints2names(b.name.map(&:to_i))}:{#{b.content}}"
+          ab = a.name | b.name
+          a_txes = a.content
+          b_txes = b.content
+          ab_txes = a_txes & b_txes
+          # check properties
+          # 1. when txes are the same
+          #    - remove B
+          #    - replace all A with union of A and B
+          if ab_txes.size > 0
+            case self.compare(a_txes,b_txes)
+            when 'EQUAL'
+              # puts "  EQUAL"
+              # puts "    removing #{@@store.ints2names(b.name.map(&:to_i))}"
+              # puts "    renaming #{@@store.ints2names(a.name.map(&:to_i))} to #{@@store.ints2names(ab.map(&:to_i))}"
+              temp = b.previous_sibling
+              root.remove!(b)
+              b = temp
+              a.each {|n| n.rename(ab | n.name)}
+            when 'A_IN_B'
+              # puts "  A in B"
+              # puts "    renaming #{@@store.ints2names(a.name.map(&:to_i))} to #{@@store.ints2names(ab.map(&:to_i))}"
+              a.each {|n| n.rename(ab | n.name)}
+            when 'B_IN_A'
+              # puts "  B in A"
+              # puts "    removing #{@@store.ints2names(b.name.map(&:to_i))}"
+              # puts "    adding child #{@@store.ints2names(ab.map(&:to_i))} to #{@@store.ints2names(a.name.map(&:to_i))}"
+              temp = b.previous_sibling
+              root.remove!(b)
+              b = temp
+              a << Tree::TreeNode.new(ab,ab_txes)
+            when 'NOT_EQUAL'
+              # puts "  NOT EQUAL"
+              # puts "    adding child #{@@store.ints2names(ab.map(&:to_i))} to #{@@store.ints2names(a.name.map(&:to_i))}"
+              a << Tree::TreeNode.new(ab,ab_txes)
+            end
+          end
+          # puts "NEW TREE:"
+          # root.print_tree(1,nil,lambda {|node,pre| puts "#{pre} #{@@store.ints2names(node.name.map(&:to_i))}:#{node.content.size}"})
+          b = b.next_sibling
+          # puts "A siblings #{a.right_siblings.map(&:name).map {|n| @@store.ints2names(n.map(&:to_i))}}"
+          # puts "A next sibling #{@@store.ints2names(a.next_sibling.name.map(&:to_i))}}"
+          # puts "A:#{@@store.ints2names(a.name.map(&:to_i))}, B:#{b.nil? ? nil : @@store.ints2names(b.name.map(&:to_i))}"
+        end # siblings.each
+        if !a.children.empty?
+          # puts "TRAVERSING DOWN"
+          self.extend_nodes(a, closed_rules: closed_rules)
+        end
+        # add node as closed rule if not subsumed by another rule already added
+        rule_frequency = a.content.size
+        rule = a.name
+        if closed_rules[rule_frequency].nil?
+          # puts "ADDING NEW CLOSED RULE: #{@@store.ints2names(rule.map(&:to_i))}:#{rule_frequency}"
+          closed_rules[rule_frequency] = [rule] 
+        else
+          if !closed_rules[rule_frequency].any? {|closed| (rule - closed).empty? }
+            # puts "ADDING NEW CLOSED RULE: #{@@store.ints2names(rule.map(&:to_i))}:#{rule_frequency}"
+            closed_rules[rule_frequency] << rule
+          else
+            # puts "RULE SUBSUMED, NOT ADDING: #{@@store.ints2names(rule.map(&:to_i))}:#{rule_frequency}"
+          end
+        end
+        current_node = current_node.next_sibling
+      end # children.each
+      return(closed_rules)
+    end #extend_nodes
+
+    def self.compare(a,b)
+          if a == b
+            return 'EQUAL'
+          # 2. when A is a subset of B
+          #    - replace all A with union of A and B
+          elsif (a - b).empty?
+            return 'A_IN_B'
+          # 2. when B is a subset of A
+          #    - remove B
+          #    - add the union as new child
+          elsif (b - a).empty?
+            return 'B_IN_A'
+          # 4. contain different elements 
+          #    - add the union as new child
+          else
+            return 'NOT_EQUAL'
+          end  
+    end
+  end
+end
+

data/lib/evoc/evaluate.rb

@@ -1,42 +1,251 @@
 module Evoc
-  class Evaluate
+  module Evaluate
     extend Logging
 
+    def self.validateInput(input)
+      # verify format
+      if !input.is_a?(Array) ||                              # not an array
+         !input.first.is_a?(Array) ||                        # not containg an array
+         ![0,1].include?(input.first.first)                  # items are not 0s and 1s
+        raise Evoc::Exceptions::FormatError.new "Wrong format given to #{__method__}, expected list of list of 0s and 1s, input was: #{input}"
+      end
+    end
 
-    def self.execute(recommendation,expected_outcome,evaluator)
-      if match = /average_precision(?<num>\d+)?/.match(evaluator)
-        if match[:num].nil?
-          self.average_precision(recommendation,expected_outcome)
-        else
-          self.average_precision(recommendation,expected_outcome,n: match[:num].to_i)
+    def self.mean_confidence(rules:)
+      if rules.empty? then return nil end
+      return (rules.inject(0) {|sum,r| sum + r.m_confidence.value}/rules.size).to_f
+    end
+
+    def self.discernibility(rec:)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      rec_size = 0
+      rec_clusters = 0
+
+      rec.each do |c|
+        rec_clusters = rec_clusters + 1
+        c.each do |e|
+          rec_size = rec_size + 1
         end
-      elsif match = /top10_recall/.match(evaluator)
-        self.top10_recall(recommendation,expected_outcome)
-      else raise ArgumentError, "The evaluator you requested (#{evaluator}) has not been implemented in Evoc::Evaluate"
       end
+      return (rec_clusters/rec_size).to_f
+
     end
 
-    # calculate the ratio of correct items in the top 10
-    # @param [Array] recommendation a sorted array 
-    # @param [Array] expected_outcome an array of items
-    # @return [Rational] the top10 recall
-    def self.top10_recall(recommendation,expected_outcome)
-        if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
-        if (expected_outcome.size > 0) & !recommendation.empty?
-          top10 = recommendation.take(10).flatten
-          common_items = (expected_outcome & top10).size.to_r
-          return common_items/expected_outcome.size
-        else
-          nil
+    def self.applicable(rec:)
+      if rec.is_a?(Array)
+        (rec <=> []).abs
+      else
+        raise Evoc::Exceptions::FormatError.new "Wrong format given to #{__method__}, expected an array, input was: #{input}"
+      end
+    end
+
+    ##
+    # @return the f1 score (preision/recall harmonic mean)
+    def self.f1(rec:,exp:)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      rec_size = 0
+      rec_correct = 0
+
+      rec.each do |c|
+        c.each do |e|
+          rec_size = rec_size + 1
+          rec_correct = rec_correct + e
+        end
+      end
+      return (2*rec_correct/(rec_size + exp)).to_f
+    end
+
+
+    ##
+    # @return the rank of the first relevant itemjk
+    def self.first_relevant(rec:)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      last_checked = 1
+      rec.each do |c|
+        c.each do |e|
+          if e == 1
+            return last_checked
+          end
+          last_checked = last_checked + 1
         end
+      end
+      return nil 
     end
 
+    ##
+    # @return the rank of the last relevant itemjk
+    def self.last_relevant(rec:)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      size = rec.inject(0) {|sum,c| sum + c.size}
+      last_checked = size
+      rec.reverse_each do |c|
+        c.reverse_each do |e|
+          if e == 1
+            return last_checked
+          end
+          last_checked = last_checked - 1
+        end
+      end
+      return nil 
+    end
+
+    def self.recall10(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+      return self.recall(rec: [rec.take(10).flatten.take(10)],exp: exp)
+    end
+
+    def self.precision10(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+      return self.precision(rec: [rec.take(10).flatten.take(10)])
+    end
+
+    def self.precision(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      size_rec = rec.inject(0) {|sum,c| sum + c.size}
+      num_correct_in_rec = rec.inject(0) {|sum,c| sum + c.inject(&:+)}
+
+      return (num_correct_in_rec/size_rec).to_f
+    end
+
+    def self.recall(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      num_correct_in_rec = rec.inject(0) {|sum,c| sum + c.inject(&:+)}
+
+      if exp.nil?
+        return num_correct_in_rec
+      else
+        if num_correct_in_rec > exp
+          raise ArgumentError, "Found more relevant items than the provided number of relevant items"
+        end
+        return (num_correct_in_rec/exp).to_f
+      end
+    end
+    # clustered recommendation is expected to be a sorted list V
+    # where V = [V1,V2,..Vn]
+    # and Vi is a cluster of items with the same weight like [rel_1,rel_2,..,rel_n]
+    # where rel_i is 1 if the item is relevant and 0 if not
+
+    # r_p : relevant items in previous groups
+    # i_p : index previous group
+    # r_g : relevant items in group
+    # n_g : items in group
+    # i   : index of current item
+    def self.t_ap(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      ap = 0
+      r_p = 0
+      i_p = 0
+      rec.each do |cluster|
+        r_g = cluster.inject(&:+).to_r
+        n_g = cluster.size.to_r
+        cluster.each_with_index do |_,i|
+          i = i_p + i + 1
+          chance_relevant = r_g/n_g
+          avg_previous_rel = if (n_g == 1)
+                               (r_p + 1) * (1/i)
+                             else
+                               (r_p + (i - i_p - 1)*((r_g-1)/(n_g-1)) + 1) * (1/i)
+                             end
+
+          item_ap_contribution = chance_relevant * avg_previous_rel
+
+          ap = ap + item_ap_contribution
+        end
+        r_p = r_p + r_g
+        i_p = i_p + n_g
+      end
+      # if the number of relevant documents is not supplied
+      # assume that the recommendation contains all relevant documents
+      if exp.nil?
+        exp = r_p
+      else
+        if r_p > exp
+          raise ArgumentError, "Found more relevant items than the provided number of relevant items"
+        end
+      end
+      return (r_p == 0 ? 0 : (ap/exp).to_f)
+    end
+
+    def self.ap(rec:,exp: nil)
+      # AP is 0 for the empty list
+      if rec.is_a?(Array) && rec.empty? # array and empty
+        return nil
+      end
+      self.validateInput(rec)
+
+      i = 0
+      correct_i = 0
+      ap = 0
+
+      rec.each do |cluster|
+        cluster.each do |item|
+          i = i + 1
+          correct_i = correct_i + item
+          precision_i = correct_i/i
+          ap = ap + (precision_i*item) 
+        end
+      end
+
+      if exp.nil?
+        exp = correct_i
+      else
+        if correct_i > exp
+          raise ArgumentError, "Found more relevant items than the provided number of relevant items"
+        end
+      end
+      return (exp == 0 ? 0 : (ap/exp).to_f)
+
+    end
     ##
     # calculate the average precision of the result based on an expected outcome
     # @param [Array] recommendation a sorted array 
     # @param [Array] expected_outcome an array of items
     # @return [Float] the average precision
-    def self.average_precision(recommendation,expected_outcome, n: recommendation.size)
+    def self.average_precision(recommendation,expected_outcome)
+        raise Error.new "#average_precision has been deprecated, use #ap instead"
         if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
         if (expected_outcome.size > 0) & !recommendation.empty?
           average_precision = 0
@@ -45,7 +254,7 @@ module Evoc
           # sort rules by weight
           # we first group rules with equal weights
           # and then sort the groups by weight
-          recommendation.take(n).each do |items|
+          recommendation.each do |items|
             if !items.is_a?(Array) then items = [items] end
             if items.first.class != expected_outcome.first.class
                 raise ArgumentError, "Expected outcome was of type #{expected_outcome.first.class}, while the item in the recommendation was of type #{items.first.class}"
@@ -71,39 +280,5 @@ module Evoc
           nil
         end
     end
-
-    # calculate the grouped average precision of the result based on an expected outcome
-    def self.e_collected_average_precision(expected_outcome)
-        if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
-        if (expected_outcome.size > 0) & !self.empty?
-          collected_average_precision = 0
-          correct_items = []
-          total_items_considered = []
-          # sort rules by weight
-          # we first group rules with equal weights
-          # and then sort the groups by weight
-          groups = self.group_by {|r| r.weight}.sort.reverse
-          groups.each do |(_,rules)|
-            items = rules.map(&:rhs).flatten.uniq
-            if (new_items = items - total_items_considered).size > 0
-              new_items.each {|item| total_items_considered << item}
-              if correct_in_group = (items & expected_outcome)
-                if correct_in_group.size > 0
-                  # make sure that the new items havent already been added earlier
-                  new_correct = (correct_in_group - correct_items)
-                  # add new items
-                  new_correct.each {|item| correct_items << item}
-                  change_in_recall = new_correct.size.to_r/expected_outcome.size
-                  precision_at_k = correct_items.size.to_r/total_items_considered.size
-                  collected_average_precision += (precision_at_k * change_in_recall)
-                end
-              end
-            end
-          end
-          self.collected_average_precision = collected_average_precision.to_f
-        else
-          self.collected_average_precision = nil
-        end
-    end
   end
 end

data/lib/evoc/exceptions/configuration_error.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class ConfigurationError < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/format_error.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class FormatError < StandardError
+    end
+  end
+end

data/lib/evoc/experiment.rb

@@ -78,6 +78,23 @@ module Evoc
     # tx_id, query
     #
     def generate_queries
+      ##
+      # write dict
+      ##
+      if path = self.opts[:write_dict]
+        tmp = Tempfile.new('dict')
+        begin
+          tmp.puts("id,name")
+          Evoc::HistoryStore.base_history.int_2_name.each do |id,name|
+            tmp.puts("#{id},#{name}")
+          end
+          tmp.close
+          FileUtils.mv(tmp.path,path)
+        ensure
+          tmp.close
+          tmp.unlink
+        end
+      end
       ##
       # WRITE CSV HEADER
       CSV {|row| row << %W(tx_id query)}
@@ -124,7 +141,7 @@ module Evoc
             # 2. randomly select X in specified = Y
             # 3. randomly select Y in tx
           elsif !random_sizes.empty? & !specified_sizes.empty?
-            specified_sizes.select! {|s| (s < tx_size) & (s > 1)} #1.
+            specified_sizes.select! {|s| (s < tx_size) & (s > 0)} #1.
             if randomly_sampled_size = specified_sizes.sample #2.
               sampled_queries = [items.sample(randomly_sampled_size)] #3.
             end
@@ -216,27 +233,53 @@ module Evoc
             break
           end
         end
+        # get query
+        query_hash = query.to_h
+        # convert query string to array of items
+        query_hash['query'] = query_hash['query'].split(',').map(&:to_i)
+        # verify query before executing
+        if tx = Evoc::HistoryStore.base_history.get_tx(id: query_hash['tx_id'],id_type: :id)
+          if !(query_hash['query'] - tx.items).empty?
+            raise Evoc::Exceptions::ConfigurationError.new "The query generated from #{query_hash['tx_id']} was not a subset of the same tx in the loaded history. The query was: '#{query_hash['query']}', the tx was '#{tx.items}'"
+          end
+        else
+          raise Evoc::Exceptions::ConfigurationError.new "Could not find the tx: '#{query_hash['tx_id']}' from #{self.opts[:queries]} in the history #{self.opts[:transactions]}"
+        end
+
         current_scenario = 1
+        last_error = 'no errors'
         # - compact removes nil values (not used factors)
         # - the splat operator '*' turns the array into parameters for #product
         # - the block form of #product makes it lazy (i.e., the whole cartesian product isn't generated at once)
         factors.first.product(*factors[1..-1]).each do |scenario|
           # Print progress to stderr
-          STDERR.print "(#{self.opts[:case_id]}) Executing scenario #{current_scenario} of #{num_of_scenarios} on query #{current_line} of #{num_lines} (scenarios skipped: #{invalid_configuration})                             \r"
+          STDERR.print "(#{self.opts[:case_id]}) Executing scenario #{current_scenario} of #{num_of_scenarios} on query #{current_line} of #{num_lines}"
+          if invalid_configuration > 0
+            STDERR.print " (scenarios skipped: #{invalid_configuration},last reason: #{last_error[0..20]}...)                             \r"
+          else
+            STDERR.print "                                \r"
+          end
 
-          query_hash = query.to_h
-          # convert query to array
-          query_hash['query'] = query_hash['query'].split(',')
           params = query_hash.merge(scenario.to_h)
           params[:case_id] = self.opts[:case_id]
           params[:granularity] = self.opts[:granularity]
           # initialize scenario
-          q =  Evoc::Scenario.new(params)
+          s =  Evoc::Scenario.new(params)
           begin
-            result = q.call(evaluators: self.opts[:evaluators]).to_json
-            $stdout.puts result
+            Evoc::RecommendationCache.get_recommendation(algorithm: s.algorithm,
+                                                         query: s.query,
+                                                         model_start: s.model_start,
+                                                         model_end: s.model_end,
+                                                         max_size: s.max_size,
+                                                         aggregator: s.aggregator,
+                                                         measures: s.measures)
+            Evoc::RecommendationCache.evaluate_last(evaluators: self.opts[:evaluators], top_k: self.opts[:top_k], unique_consequents: self.opts[:unique_consequents], expected_outcome: s.expected_outcome,measure_combination: s.measures)
+            result = Evoc::RecommendationCache.to_h(measures: s.measures)
+            # merge scenario params with result hash and dump as json
+            $stdout.puts s.to_h.merge(result).to_json
           rescue ArgumentError => e
             invalid_configuration += 1
+            last_error = e.message
           end
           current_scenario += 1
         end

data/lib/evoc/recommendation_cache.rb

@@ -9,7 +9,7 @@ module Evoc
         # time: the time it took to generate the currently cached recommendation
         # model_size: the number of transactions used when generating the currently cached recommendation
         class << self
-            attr_accessor :tag, :base_recommendation, :last_recommendation, :time_rulegeneration, :time_measurecalculation, :time_aggregation, :time_evaluation, :filtered_model_size, :evaluation
+            attr_accessor :tag, :base_recommendation, :last_recommendation, :time_rulegeneration, :time_measurecalculation, :time_aggregation, :filtered_model_size, :evaluation
         end
 
         def self.recommendation_cached?(algorithm:,
@@ -20,6 +20,7 @@ module Evoc
             return self.tag == [algorithm,query,model_start,model_end,max_size].hash
         end
 
+
         def self.get_recommendation(algorithm:,
                                     query:,
                                     model_start:,
@@ -75,14 +76,13 @@ module Evoc
         # @param [Array<String>] measure_combinations the list of measures to use when sorting a recommendation before evaluating
         #
         # @return [Hash[aggregator][evaluator][result]] the hash of results
-        def self.evaluate(evaluators: ,expected_outcome:,measure_combination: )
+        def self.evaluate_last(evaluators: ,top_k: nil, unique_consequents: nil,expected_outcome:,measure_combination: )
           if !self.last_recommendation.nil?
-            t1 = Time.new
-            evaluators.each do |evaluator|
-              self.evaluation[evaluator] = self.last_recommendation.evaluate_with(evaluator: evaluator,expected_outcome: expected_outcome,measure_combination: measure_combination)
-            end
-            t2 = Time.new
-            self.time_evaluation = TimeDifference.between(t1,t2).in_seconds.round(8)
+              self.evaluation = self.last_recommendation.evaluate_with(evaluators: evaluators,
+                                                            top_k: top_k,
+                                                            unique_consequents: unique_consequents,
+                                                            expected_outcome: expected_outcome,
+                                                            measure_combination: measure_combination)
           else
             STDERR.puts "TAG = #{self.tag}No recommendation to evaluate"
           end
@@ -94,10 +94,7 @@ module Evoc
         #       time: 'execution time',
         #       filtered_model_size: 
         #       number_of_rules :
-        #       evaluation: {
-        #           average_precision: ..,
-        #           ..next evaluator..
-        #       }
+        #       average_precision: 
         #       rules: [
         #         {
         #           lhs: [lhs]
@@ -118,7 +115,6 @@ module Evoc
             recommendation_hash[:time_rulegeneration] = self.time_rulegeneration
             recommendation_hash[:time_measurecalculation] = self.time_measurecalculation
             recommendation_hash[:time_aggregation] = self.time_aggregation
-            recommendation_hash[:time_evaluation] = self.time_evaluation
             recommendation_hash[:filtered_model_size] = self.filtered_model_size
             recommendation_hash[:number_of_baserules] = self.base_recommendation.size
             recommendation_hash[:number_of_rules] = self.last_recommendation.size
@@ -128,10 +124,11 @@ module Evoc
               sum + r.get_measure('m_hyper_coefficient').value } / self.last_recommendation.size
             recommendation_hash[:largest_antecedent] = self.last_recommendation.largest_antecedent
             if !self.evaluation.nil?
-                self.evaluation.each do |evaluator,value|
-                    recommendation_hash[evaluator.to_sym] = value[:value]
-                    recommendation_hash[:unique_consequents] = value[:unique_consequents]
-                end
+              self.evaluation.each do |evaluator,results|
+                recommendation_hash[evaluator] = results['value']
+                # time can also be added like this:
+                # recommendation_hash[evaluator+'_time'] = results['time']
+              end
             end
             recommendation_hash[:rules] = []
             self.last_recommendation.each do |rule|

data/lib/evoc/rule.rb

@@ -21,15 +21,19 @@ module Evoc
       name
     end
 
+    def human_name
+      "#{human_lhs} -> #{human_rhs}"
+    end
+
     def human_lhs
-      if !self.tx_store.nil? & self.lhs.all? {|i| i.is_a?(Numeric)}
-        self.lhs.map{|i| self.tx_store.int_2_name[i]}
+      if !self.tx_store.nil? # & self.lhs.all? {|i| i.is_a?(Numeric)}
+        self.tx_store.ints2names(self.lhs.map(&:to_i)).join(',')
       end
     end
 
     def human_rhs
-      if !self.tx_store.nil? & self.rhs.all? {|i| i.is_a?(Numeric)}
-        self.rhs.map{|i| self.tx_store.int_2_name[i]}
+      if !self.tx_store.nil? #& self.rhs.all? {|i| i.is_a?(Numeric)}
+        self.tx_store.ints2names(self.rhs.map(&:to_i)).join(',')
       end
     end
 

data/lib/evoc/rule_store.rb

@@ -116,6 +116,33 @@ module Evoc
     end
 
 
+    # Needed by Evaluate mixin
+    def evaluation_format(measures:, expected_outcome:)
+      current_weight = nil
+      current_group = []
+      recommendation = []
+      # sort and filter out duplicate consequents
+      self.sort_on(measures: measures, rules: self.unique_by(measures.first)).each do |r|
+        expected = ((r.rhs - expected_outcome).empty? ? 1 : 0)
+        weight_tag = measures.map {|m| r.get_measure(m).value.nil? ? "INF" : r.get_measure(m).to_s}.join('_')
+        if current_weight.nil?
+          current_weight = weight_tag
+        end
+        if weight_tag == current_weight
+          current_group << expected
+        else
+          recommendation << current_group
+          current_group = [expected]
+          current_weight = weight_tag
+        end
+      end
+      # add last group if not empty
+      if !current_group.empty?
+        recommendation << current_group
+      end
+      return recommendation
+    end
+
     ##
     # Evaluate this recommendation using the given evaluator
     #
@@ -126,27 +153,35 @@ module Evoc
     # @param [String] evaluator the method to use for evaluating
     # @param [Array] expected_outcome the list of items to evaluate against
     # @param [Array] measure_combination the list of measures used to first sort the recommendation
-    def evaluate_with(evaluator: :average_precision,expected_outcome:,measure_combination: )
+    def evaluate_with(evaluators:,expected_outcome:,measure_combination:,top_k: nil,unique_consequents: nil)
       if measure_combination.empty? then raise ArgumentError, "Cannot evalute a recommendation without specifying which measures to rank on" end
-      result = Hash.new 
-      logger.debug "#{__method__} params: evaluator: #{evaluator}, measure_combination: #{measure_combination}"
+      logger.debug "#{__method__} params: evaluators: #{evaluators}, measure_combination: #{measure_combination}"
       # sort the rules on each combination and evaluate 
-      sorted_rules = []
-      if self.aggregator =~ /_hc\z/
-        sorted_rules = self.sort_on(measures: measure_combination+['m_hyper_coefficient'])
-      elsif !self.aggregator.nil?
-        sorted_rules = self.sort_on(measures: measure_combination)
-      else
-        # not an aggregation
-        # get the strongest unique rules
-        unique_rules = self.unique_by(measure_combination.first)
-        sorted_rules = self.sort_on(rules: unique_rules,measures: measure_combination)
-      end
-      # get the recommended items
-      recommendation = sorted_rules.map(&:rhs)
+      # if !top_k.nil?
+      #   raise ArgumentError, "Top K must be a number" unless top_k.is_a?(Numeric)
+      #   sorted_rules = sorted_rules.take(top_k)
+      # end
+      # convert rules into format used in evaluation
+      # map to 0/1 list where 1 is a correct item and 0 is not
+      # second item in each tuple gives the weight of the rule
       # evaluate the sorted list against the expected outcome 
-      result[:value] = Evoc::Evaluate.execute(recommendation,expected_outcome,evaluator)
-      return result
+      recommendation = self.evaluation_format(measures: measure_combination, expected_outcome: expected_outcome)
+      potential_params = {rec: recommendation, exp: expected_outcome.size, rules: self}
+      results = Hash.new
+      evaluators.each do |evaluator|
+            t1 = Time.new
+            if Evoc::Evaluate.respond_to?(evaluator)
+              results[evaluator] = Hash.new
+              method_params = Evoc::Evaluate.method(evaluator).parameters.map(&:second)
+              params = potential_params.select {|k,v| method_params.include?(k)} 
+              results[evaluator]['value'] = Evoc::Evaluate.method(evaluator).call(params)
+            else
+              raise NoMethodError, "The evaluator you requested (#{evaluator}) has not been implemented in Evoc::Evaluate"
+            end
+            t2 = Time.new
+            results[evaluator]['time'] = TimeDifference.between(t1,t2).in_seconds.round(8)
+      end
+      return results
     end
     
     ##
@@ -163,9 +198,9 @@ module Evoc
     # where each consequent is the strongest given by the input measure
     #
     # @param: [String] measure the measure used to find the strongest rules
-    def unique_by(measure)
+    def unique_by(measure, rules: self)
       selected_rules = Evoc::Env::GOOGLE_HASH ? GoogleHashSparseIntToRuby.new : Hash.new
-      self.each do |rule|
+      rules.each do |rule|
         if !rule.get_measure(measure).value.nil?
 	key = rule.rhs.first
           if selected_rules[key].nil?
@@ -223,7 +258,7 @@ module Evoc
         csv << ['rule'] + defined_measures
         self.each do |rule|
           row = CSV::Row.new([],[],false)
-          row << rule.name
+          row << rule.human_name
           defined_measures.each do |m| 
             row << rule.get_measure(m).value
           end
@@ -287,11 +322,9 @@ module Evoc
     end
 
     def ==other
-      ( self.map(&:lhs)  == other.map(&:lhs) ) &
-      ( self.map(&:rhs)  == other.map(&:rhs) ) &
-      Evoc::Rule.measures.each do |m|
-        self.map {|r| r.get_measure(m)} == other.map {|r| r.get_measure(m)}
-      end
+      self_rules = self.rules.sort_by {|r| r.name}.map {|r| "#{r.name}#{r.instantiated_measures.map {|m| r.get_measure(m).value}}"}
+      other_rules = other.rules.sort_by {|r| r.name}.map {|r| "#{r.name}#{r.instantiated_measures.map {|m| r.get_measure(m).value}}"}
+      self_rules == other_rules
     end
 
     def size

data/lib/evoc/scenario.rb

@@ -53,30 +53,6 @@ module Evoc
       comparison
     end
 
-    ##
-    # Executes a query given the current paramaters
-    # This results in a set of association rules, i.e., a recommendation
-    #
-    # Producing a recommendation is done through the following process:
-    #
-    # 1. Generate rules using a mining algorithm on the specified history
-    # 2. Calculate interestingness measures on the generated rules
-    # (optional) 3. Aggregate rules to further improve recommendation
-    # (optional) 4. Evaluate how good the recommendation is
-    #
-    # @return [Hash] containing the query + scenario + recommendation + other metadata
-    def call(evaluators: [])
-      #generate recommendation in cache (generate rules + measures on rules)
-      self.recommendation
-
-      # evaluate if requested
-      if !evaluators.empty?
-        Evoc::RecommendationCache.evaluate(evaluators: evaluators,expected_outcome: self.expected_outcome,measure_combination: self.measures)
-      end
-      # build return hash
-      recommendation = Evoc::RecommendationCache.to_h(measures: self.measures)
-      return self.to_h.merge(recommendation)
-    end
 
     def to_h
       fields = %w(case_id granularity scenario_id tx_id tx_index tx_size query_size query_percentage expected_outcome_size model_size model_hours model_age max_size algorithm aggregator measures)
@@ -88,16 +64,6 @@ module Evoc
       return hash
     end
 
-    def recommendation
-        Evoc::RecommendationCache.get_recommendation(algorithm: self.algorithm,
-                                                      query: self.query,
-                                                      model_start: self.model_start,
-                                                      model_end: self.model_end,
-                                                      max_size: self.max_size,
-                                                      aggregator: self.aggregator,
-                                                      measures: self.measures)
-    end
-
     def recommendation?
         Evoc::RecommendationCache.recommendation_cached?(algorithm: self.algorithm,
                                                       query: self.query,

data/lib/evoc/tree/tree_node.rb

@@ -0,0 +1,26 @@
+# Extending the rubytree gem with some additional methods
+# see: http://rubytree.anupamsg.me/
+module Tree
+  class TreeNode
+
+    ##
+    # @return the right siblings of the current node
+    def right_siblings
+      if self.is_last_sibling?
+        return []
+      else
+        return [self.next_sibling] + self.next_sibling.right_siblings
+      end
+    end
+
+    ##
+    # @return the left siblings of the current node
+    def left_siblings
+      if self.is_first_sibling?
+        return []
+      else
+        return [self.previous_sibling] + self.previous_sibling.left_siblings
+      end
+    end
+  end
+end

data/lib/evoc/tx_store.rb

@@ -26,6 +26,14 @@ module Evoc
     end
 
 
+    def names2ints(names)
+      names.map {|n| self.name_2_int[n]}
+    end
+
+    def ints2names(ints)
+      ints.map {|i| self.int_2_name[i]}
+    end
+
     ##
     # self << tx
     #

data/lib/evoc/util.rb

@@ -0,0 +1,37 @@
+
+module Evoc
+  module Util
+    # helper function to generate a lattice so we can easily come up with tests for the closed rules mining
+    # examples nodes: [['a',[1,2]],['b',[2,3]],['c',[1,2,3]]]
+    # first elem is item name
+    # second elem is the txes where this item changes 
+    def self.lattice(nodes,filter: nil)
+      (1..nodes.size).each do |n|
+        nodes.combination(n).each do |comb|
+          # [['a',[1,2]],['b',[2,3]]]
+          union = comb.map(&:first).join(',')
+          frequency = comb.map(&:second).inject(&:&).size
+          if filter =~ union
+            if frequency > 0
+              printf("%#{nodes.size*2}s",[union,frequency].join(':'))
+            end
+          end
+        end
+        puts
+      end
+    end
+
+    # helper function for generating a txstore from the following format
+    # [['a',[1,2]],['b',[2,3]],['c',[1,2,3]]]
+    # (same structure as used for lattice creation)
+    def self.nodes2txstore(nodes)
+      txes = nodes.map(&:second).inject(&:|)
+      store = Evoc::TxStore.new
+      txes.each do |id|
+        items = nodes.select {|n| n.second.include?(id)}.map(&:first)
+        store << Evoc::Tx.new(id: id, items: items)
+      end
+      return(store)
+    end
+  end
+end

data/lib/evoc/version.rb

@@ -1,3 +1,3 @@
 module Evoc
-  VERSION = "3.6.2"
+  VERSION = "3.7.0"
 end

data/lib/evoc_cli/experiment.rb

@@ -1,10 +1,20 @@
 require_relative 'cli_helper'
+# override printing of help text as the default does not respect spaces and adds newlines
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        stdout.puts message
+      end
+    end
+  end
+end
 
 module EvocCLI
   class Experiment < Thor
     class_option :case_id, type: :string, desc: "Specify case identifier."
     class_option :logger_level, type: :string, default: 'error', desc: "The severity level to output to debug.log"
-    class_option :transactions, :aliases => '-t', :type => :string, :required => true, :desc => "Path to change-history"
+    class_option :transactions, :aliases => '-t', :type => :string, :desc => "Path to change-history"
     class_option :granularity, type: :string, default: 'mixed', desc: "The granularity level of imported items from history"
 
     ##
@@ -35,6 +45,7 @@ module EvocCLI
       desc: "Percentage of items to select for each query"
     method_option :filter_duplicates, aliases: '-d', type: :boolean, desc: "Remove identical queries (same id/algorithm/items/model_size/max_size)"
     method_option :filter_expected_outcome, aliases: '-n', type: :boolean, desc: "Remove new files from the expected outcome"
+    method_option :write_dict, type: :string, desc: "Write an item dictionary to the provided file"
     desc "generate_queries [options]", "Generate queries from <transactions>"
     def generate_queries
       #MemoryProfiler.start('create_queries',30)
@@ -59,7 +70,52 @@ module EvocCLI
       desc: "DEPRECATED WILL HAVE NO EFFECT    Number of query permutations/replications to produce."
     method_option :fail_safe, type: :string, desc: "If the fail safe file exists, safely exit."
     method_option :evaluators, aliases: '-e', type: :array, enum: ['average_precision'], required: false, desc: "Methods for evaluating the recommendations"
+    method_option :unique_consequents, type: :boolean, default: false, desc: "Filter our duplicate consequents when evaluating, keeping the strongest. Only has effect when evaluating non-aggregated recommendations."
+    method_option :top_k, type: :numeric, required: false, desc: "Evaluate over the top K items, these are selected AFTER an evential unique consequents filter"
     desc "execute_scenarios [options]",""
+    long_desc <<-LONGDESC
+  keyword                  description
+  -------                  -----------
+
+  case_id:                 user provided tag for the history used
+  granularity:             granularity of the history used
+  scenario_id:             a unique indentifier for this scenario
+  tx_id:                   the sha of the commit that the query was sampled from
+  tx_index:                the index of this transaction in the used history (0 is oldest)
+  tx_size:                 the number of items in the transaction
+  query_size:              the number of items in the query
+  query_percentage:        query_size/tx_size
+  expected_outcome_size:   tx - query
+  model_size:              number of previous transactions relative to this one
+  model_hours:             time span from the first transaction to this one
+  model_age:               number of transactions between end of model and this transaction
+  max_size:                transactions larger than this are filtered out before generating rules
+  filtered_model_size:     model size after the max_size filtering
+  algorithm:               the mining algorithm used to generate the recommendation
+  aggregator:              the aggregation function used to aggregate the rules of the recommendation
+  measures:                the interestingnessmeasures used to rank each rule
+  recommendation_tag:      a unique identifiter of the rules used as a basis for the recommendation
+  time_rulegeneration:     how long it took to generate the rules
+  time_measurecalculation: how long it took to calculate the measures for each rule
+  time_aggregation:        how long it took to aggregate the rules
+  number_of_baserules:     number of rules before aggregation
+  number_of_rules:         number of rules after aggregation (equal to number_of_baserules when not aggregating)
+  number_of_hyperrules:    number of hyper rules after aggregating
+  mean_hyper_coefficient:  average number of rules aggregated in each hyper rule
+  largest_antecedent:      number of items in the largest antecedent (lhs of rule)
+  t_ap:                    average precision where ties are accounted for
+  ap:                      the average precision
+  precision:               ratio of correct to incorrect items
+  precision10:             ratio of correct to incorrect items in the top 10
+  recall:                  ratio of correct items in recommendation to full set of expected items 
+  recall19:                ratio of correct items in recommendation to full set of expected items in the top 10
+  mean_confidence:         the average confidence of the rules in this recommendation
+  discernibility:          the number of uniquely weighted rules to the number of rules
+  applicable:              1 if rules were generated, 0 otherwise
+  f1:                      the f1 measure
+  first_relevant:          the rank of the first correct item
+  last_relevant:           the rank of the last correct item
+  LONGDESC
     def execute_scenarios
       if !options[:permutation].nil?
         STDERR.puts "Permutation option has been set, but the option is currently disabled and will have no effect"

data/lib/evoc_helper.rb

@@ -28,7 +28,10 @@ require 'logger'
 require 'zip'
 require 'zip/filesystem'
 require 'set'
+require 'tempfile'
+require 'fileutils'
 require 'algorithms' # various efficient data structures
+require 'tree' #general purpose tree structure
 require 'mathn' # enhances the Rational (and others) number type
 Evoc::Env.load('google_hash',"please install to improve performance")
 #Evoc::Env.load('nmatrix')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evoc
 version: !ruby/object:Gem::Version
-  version: 3.6.2
+  version: 3.7.0
 platform: ruby
 authors:
 - Thomas Rolfsnes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-20 00:00:00.000000000 Z
+date: 2017-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - mail@thomasrolfsnes.com
@@ -172,12 +186,15 @@ files:
 - evoc.gemspec
 - lib/evoc.rb
 - lib/evoc/algorithm.rb
+- lib/evoc/algorithms/closed_rules.rb
 - lib/evoc/algorithms/top_k.rb
 - lib/evoc/analyze.rb
 - lib/evoc/array.rb
 - lib/evoc/evaluate.rb
 - lib/evoc/exceptions/aggregation_error.rb
+- lib/evoc/exceptions/configuration_error.rb
 - lib/evoc/exceptions/expectedoutcome_nil_or_empty.rb
+- lib/evoc/exceptions/format_error.rb
 - lib/evoc/exceptions/measure_calculation_error.rb
 - lib/evoc/exceptions/no_changed_items_in_changes.rb
 - lib/evoc/exceptions/no_changes_in_json_object.rb
@@ -206,8 +223,10 @@ files:
 - lib/evoc/rule_store.rb
 - lib/evoc/scenario.rb
 - lib/evoc/svd.rb
+- lib/evoc/tree/tree_node.rb
 - lib/evoc/tx.rb
 - lib/evoc/tx_store.rb
+- lib/evoc/util.rb
 - lib/evoc/version.rb
 - lib/evoc_cli/analyze.rb
 - lib/evoc_cli/cli_helper.rb