fp-growth 1.0.0

data/README

@@ -0,0 +1,5 @@
+This is an implementation of the fp-growth frequent pattern mining algorithm as
+stated in the paper
+
+Mining Frequent Patterns without Candidate Generation: A Frequent-Pattern Tree Approach
+Han et al, Data Mining and Knowledge Discovery, 8, 53-87, 2004

data/examples/cao.rb

@@ -0,0 +1,207 @@
+begin
+  require 'rubygems'
+  require 'fp_growth'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'fp_growth'
+end
+
+require 'mysql'
+require 'singleton'
+
+HOST =
+USER =
+PASSWD =
+DB =
+
+# This example shows the usage of fp-growth with a database from an
+# inventory management system called cao_faktura (http://www.cao-faktura.de/)
+class CaoDb
+  
+  include Singleton
+  
+  def initialize
+    connect
+  end
+  
+  def article_tree(min_support)
+    FpGrowth::FpTree.new(min_support, article_ids(min_support), article_transactions)
+  end
+
+  def category_tree(min_support)
+    transactions = category_transactions
+    FpGrowth::FpTree.new(min_support, FpGrowth::FpTree.get_items(transactions), transactions)
+  end
+
+  def article_name(id)
+    @connection.query(%Q!
+      SELECT KURZNAME
+      FROM ARTIKEL
+      WHERE REC_ID = #{id}
+    !).each do |row|
+      return row[0]
+    end
+  end
+
+  def category_name(id)
+    @connection.query(%Q!
+      SELECT NAME
+      FROM WARENGRUPPEN
+      WHERE ID = #{id}
+    !).each do |row|
+      return row[0]
+    end
+  end
+
+  def article_ids(min_support)
+    result = []
+    data = @connection.query(%Q!
+      SELECT ARTIKEL_ID,
+        # ein Bon kann mehrere journalpos mit ident. Artikel enthalten
+        # und soll trotzdem nur einmal gezählt werden
+        COUNT(DISTINCT JOURNAL_ID) AS anzahl
+      FROM JOURNALPOS
+      GROUP BY ARTIKEL_ID
+      HAVING anzahl >= #{min_support}
+      # mit zwei spalten ist Sortierung eindeutig
+      ORDER BY anzahl DESC, ARTIKEL_ID DESC
+    !)
+    data.each do |row|
+      result << [ row[0].to_i, row[1].to_i ]
+    end
+    data.free
+    result
+  end
+  
+  def category_ids(min_support)
+    result = []
+    data = @connection.query(%Q!
+      SELECT WARENGRUPPE,
+        COUNT(DISTINCT JOURNAL_ID) AS anzahl
+      FROM JOURNALPOS
+      GROUP BY ARTIKEL_ID
+      HAVING anzahl >= #{min_support}
+      ORDER BY anzahl DESC, WARENGRUPPE DESC
+    !)
+    data.each do |row|
+      result << [ row[0].to_i, row[1].to_i ]
+    end
+    data.free
+    result
+  end
+  
+  def article_transactions
+    result = []
+    data = @connection.query(%q!
+      SELECT JOURNAL_ID,
+      CONVERT(GROUP_CONCAT(ARTIKEL_ID SEPARATOR ',') USING UTF8)
+      FROM JOURNALPOS
+      GROUP BY JOURNAL_ID
+    !)
+    data.each do |row|
+      result << row[1].split(',').collect { |id| id.to_i }
+    end
+    data.free
+    result
+  end
+  
+  def category_transactions
+    result = []
+    data = @connection.query(%q!
+      SELECT JOURNAL_ID,
+      CONVERT(GROUP_CONCAT(WARENGRUPPE SEPARATOR ',') USING UTF8)
+      FROM JOURNALPOS
+      GROUP BY JOURNAL_ID
+    !)
+    data.each do |row|
+      result << row[1].split(',').collect { |id| id.to_i }
+    end
+    data.free
+    result
+  end
+  
+  def count_transactions
+    @connection.query(%q!
+      SELECT COUNT(*) FROM JOURNAL
+    !).each do |row|
+      return row[0].to_i
+    end
+  end
+  
+  def do_articles(min_support, min_confidence)
+    print_article_assoziation_rules(article_tree(min_support).create_assoziation_rules(min_confidence))
+  end
+private
+
+  def connect
+    @connection = Mysql::new(HOST, USER, PASSWD, DB)
+    @connection.query('SET NAMES "UTF8"')
+  end
+end
+
+def is_unnecessary_rule?(all, wanted, beta)
+  all.each do |candidate|
+    next if candidate[:right] != wanted[:right] 
+    next if !candidate[:left].is_superset_of?(wanted[:left])
+    next if !candidate[:confidence].between?(wanted[:confidence] - beta, wanted[:confidence] + beta)
+    return true
+  end
+  false
+end
+
+def remove_unnecessary_rules(all, beta)
+  all.select { |candidate| !is_unnecessary_rule?(all, candidate, beta) }
+end
+
+def print_article_assoziation_rules(array)
+  array.each { |rule| print_article_assoziation_rule(rule) }
+end
+
+def print_article_assoziation_rule(rule)
+  print '['
+  rule[:left].each do |id|
+    print "(#{id}:#{CaoDb.instance.article_name(id)})"
+  end
+  print '] => ['
+  rule[:right].each do |id|
+    print "(#{id}:#{CaoDb.instance.article_name(id)})"
+  end
+  print '] = '
+  puts sprintf('s%i c%.2f', rule[:support], rule[:confidence])
+end
+
+def print_category_assoziation_rules(array)
+  array.each do |rule|
+    print '['
+    rule[:left].each do |id|
+      print "(#{id}:#{CaoDb.instance.category_name(id)})"
+    end
+    print '] => ['
+    rule[:right].each do |id|
+      print "(#{id}:#{CaoDb.instance.category_name(id)})"
+    end
+    print '] = '
+    puts sprintf('s%i c%.2f', rule[:support], rule[:confidence])
+  end
+end
+
+def do_categories(min_support, min_confidence)
+  frequent_patterns = CaoDb.instance.category_tree(min_support).fp_growth
+  print_category_assoziation_rules(FpGrowth::Helper.create_assoziation_rules(frequent_patterns, min_confidence))
+end
+
+def do_articles(min_support, min_confidence)
+  frequent_patterns = CaoDb.instance.article_tree(min_support).fp_growth
+  print_article_assoziation_rules(
+    remove_unnecessary_rules(
+      FpGrowth::Helper.create_assoziation_rules(frequent_patterns, min_confidence),
+      0.2
+    )
+  )
+end
+
+min_support = 9 # abs = (rel * database.count_transactions).round
+min_confidence = 0.5
+
+do_articles(min_support, min_confidence)
+#CaoDb.instance.article_tree(min_support).save

data/examples/small_ones.rb

@@ -0,0 +1,56 @@
+begin
+  require 'rubygems'
+  require 'fp_growth'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'fp_growth'
+end
+
+def example_1 # paper
+  transactions = [
+    ['f', 'a', 'c', 'd', 'g', 'i', 'm', 'p'],
+    ['a', 'b', 'c', 'f', 'l', 'm', 'o'],
+    ['b', 'f', 'h', 'j', 'o'],
+    ['b', 'c', 'k', 's', 'p'],
+    ['a', 'f', 'c', 'e', 'l', 'p', 'm', 'n']
+  ]
+  FpGrowth::FpTree.new(3, v.get_items(transactions), transactions)
+end
+
+def example_2 # buch s 123
+  transactions = [
+    [1,3,6,8,9],
+    [1,2,3,6,7,8],
+    [2,4,6],
+    [2,3,4,9],
+    [1,3,5,6,7,8,9]
+  ]
+  FpGrowth::FpTree.new(3, FpGrowth::FpTree.get_items(transactions), transactions)
+end
+
+def example_3
+  transactions = [
+    [1,3,4],
+    [4],
+    [1,2,4,5],
+    [1,6],
+    [1,2],
+    [1,6],
+    [1,4],
+    [1,2,4]
+  ]
+  FpGrowth::FpTree.new(2, FpGrowth::FpTree.get_items(transactions), transactions)
+end
+
+def example_4 # thesis adaptive-fp
+  transactions = [
+    ['a', 'c', 'd', 'e', 'f'],
+    ['a', 'b', 'e'],
+    ['c', 'e', 'f'],
+    ['a', 'c', 'd', 'f'],
+    ['c', 'e', 'f']
+  ]
+  FpGrowth::FpTree.new(2, FpGrowth::FpTree.get_items(transactions), transactions)
+end
+
+puts example_4

data/lib/fp_growth.rb

@@ -0,0 +1,9 @@
+require 'fp_growth/inflections'
+
+module FpGrowth
+  autoload :FpTreeNode, 'fp_growth/fp_tree_node'
+  autoload :FpTree, 'fp_growth/fp_tree'
+  autoload :HeaderListNode, 'fp_growth/header_list_node'
+  autoload :HeaderList, 'fp_growth/header_list'
+  autoload :PrefixPath, 'fp_growth/prefix_path'
+end

data/lib/fp_growth/fp_tree.rb

@@ -0,0 +1,220 @@
+module FpGrowth::Helper
+  def self.subsets_as_prefix_path(array)
+    result = []
+    array.subsets.each do |combination|
+      min_support = combination.min { |a, b| a.count <=> b.count }.count
+      elements = combination.collect { |c| c.key }
+      result << FpGrowth::PrefixPath.new(min_support, elements)
+    end
+    result
+  end
+  
+  # takes arrays of prefix_paths
+  def self.cross_product(a, b)
+    result = []
+    a.each do |a_el|
+      b.each do |b_el|
+        result << (a_el + b_el)
+      end
+    end
+    result
+  end
+
+  # TODO put handling of assoziation rules in an extra namespace
+  # and copy the unnecessary rules code from examples/cao.rb in it too
+  def self.create_assoziation_rules(frequent_patterns, min_confidence)
+    result = []
+    frequent_patterns.each do |pattern|
+      next if pattern.size < 2
+      pattern.to_a.parts.each do |part|
+        other_pattern = frequent_patterns.find { |p| part.first.content_equal?(p.to_a) }
+        confidence = pattern.support.to_f / other_pattern.support.to_f
+        if confidence >= min_confidence
+          result << {
+            :left => part.first,
+            :right => part.last,
+            :support => pattern.support,
+            :confidence => confidence
+          }
+        end
+      end
+    end
+    result
+  end
+
+end
+
+class FpGrowth::FpTree
+
+  attr_reader :min_support, :root
+  attr_accessor :header_list
+  protected :header_list, :header_list=, :root
+  
+  # items is sorted array of [key, count]
+  # min_support is not in %, but absolute
+  def initialize(min_support, items, transactions = [])
+    @min_support = min_support
+    @root = FpGrowth::FpTreeNode.new(nil)
+    
+    # the count information is lost in this step
+    # HeaderList calculates this value again if needed
+    @header_list = FpGrowth::HeaderList.new(select_only_frequent_items(items))
+    
+    add_transactions(transactions)
+  end
+
+  def empty?
+    @root.children.empty?
+  end
+  
+  def add_transactions(transactions)
+    transactions.each do |transaction|
+      add_transaction(transaction)
+    end
+  end
+  
+  # TODO decide: bild header list online or with rebuild_header_list afterwards 
+  def add_transaction(transaction)
+    transaction = prepare_transaction(transaction)
+    increment = transaction.support
+    tree_node = @root
+    transaction.each do |key|
+      if next_node = tree_node.find_child(key)
+        next_node.increase_count(increment)
+      else
+        next_node = FpGrowth::FpTreeNode.new(key, increment)
+        tree_node.add_child(next_node)
+        
+        @header_list[key] << next_node
+      end
+
+      tree_node = next_node
+    end
+  end
+  
+  def to_s
+    if false
+      @root.to_s
+    else
+      result = "Tree (min_s = #{@min_support})\n"
+      result << @root.to_s
+      result << "\nHeader list\n"
+      result << @header_list.to_s
+      result
+    end
+  end
+
+  # arg is new root
+  def subtree(root_node)
+    result = FpGrowth::FpTree.new(@min_support, [])
+    root_node.clone_children(result.root)
+    result.rebuild_header_list
+    result
+  end
+
+  def fp_growth(alpha = nil)
+    single, multi = split_paths
+    single_teil = []
+    multi_teil = []
+    if single
+      single_teil = FpGrowth::Helper.subsets_as_prefix_path(single)
+    end
+    if multi
+      multi.header_list.each do |node|
+        immediate_frequent_pattern = node.immediate_frequent_pattern
+        multi_teil << immediate_frequent_pattern
+        new_tree = node.conditional_fp_tree(@min_support)
+        if !new_tree.empty?
+          multi_teil += new_tree.fp_growth(immediate_frequent_pattern)
+        end
+      end
+    end
+    FpGrowth::Helper.cross_product(single_teil + multi_teil + FpGrowth::Helper.cross_product(single_teil, multi_teil), [alpha])
+  end
+
+  # slow version used only as reference for testing
+  # does not split tree in single- and multipath parts
+  def fp_growth_slow(alpha = nil)
+    result = []
+    header_list.each do |node|
+      base_path = node.immediate_frequent_pattern + alpha
+      result << base_path
+      new_tree = node.conditional_fp_tree(@min_support)
+      if !new_tree.empty?
+        result += new_tree.fp_growth_slow(base_path)
+      end
+    end
+    result
+  end
+  
+  # can be used with Array or PrefixPath
+  # returns sorted array of [key, count]
+  def self.get_items(transactions)
+    result = {}
+    
+    transactions.each do |transaction|
+  
+      increment = transaction.respond_to?(:support) ? transaction.support : 1
+    
+      transaction.each do |item|
+        result[item] ||= 0
+        result[item] += increment
+      end
+    end
+    result.to_a.
+      sort { |a, b| b.last <=> a.last }
+  end
+
+  def save(filename = 'fp_tree.txt')
+    File.open(filename, 'w') do |file|
+      file.write Marshal.dump(self)
+    end
+  end
+  
+  def self.load(filename = 'fp_tree.txt')
+    Marshal.load(IO.read(filename))
+  end
+  
+protected
+
+  def rebuild_header_list
+    @root.each do |node|
+      @header_list[node.key] << node
+    end
+    @header_list.sort
+  end
+  
+private
+
+  # returnvalue is array of two elements
+  # first element is nil or array of tree_nodes which form the single prefix path
+  # second element is nil or FpTree which forms the multipath part
+  def split_paths
+    return [nil, self] if @root.children.size != 1
+    single = []
+    node = @root
+    while node.children.size == 1
+      # this leaves out root
+      node = node.children.first
+      single << node
+    end
+    multi = node.children.empty? ? nil : subtree(node)
+    [single, multi]
+  end
+
+  # removes non-frequent-items and sorts remaining frequent-items on stored ordered-items
+  # arg can be Array or PrefixPath
+  # returns PrefixPath
+  def prepare_transaction(transaction)
+    support = transaction.respond_to?(:support) ? transaction.support : 1
+    # relies on the fact that Array#& keeps order of first array
+    FpGrowth::PrefixPath.new(support, @header_list.all_keys & transaction.to_a)
+  end
+  
+  # takes array of [key,count]
+  # keeps order
+  def select_only_frequent_items(items)
+    items.select { |item| item.last >= @min_support }
+  end
+
+end

data/lib/fp_growth/fp_tree_node.rb

@@ -0,0 +1,81 @@
+require 'set'
+
+# knows nothing about header list
+class FpGrowth::FpTreeNode
+
+  attr_reader :key, :children, :count
+  attr_accessor :parent
+
+  protected :parent=
+  
+  def initialize(key, count = 1)
+    @key = key
+    @count = count
+    @parent = nil
+    @children = []
+  end
+
+  def add_child(child)
+    @children << child
+    child.parent = self
+  end
+  
+  def find_child(key)
+    children.find { |child| child.key == key }
+  end
+  
+  # prints tree structure
+  def to_s(depth = 0)
+    if false
+      title = @key ? "#{@key}:#{count}" : 'root'
+      "( #{title} #{@children.collect { |child| child.to_s }.join(' ')})"
+    else
+      result = key ? "#{@key}:#{count} " : ''
+      result << @children.collect { |child| child.to_s(depth + 1) }.join("\n" << ' ' * 4 * depth)
+      result
+    end
+  end
+
+  def increase_count(value = 1)
+    @count += value
+  end
+
+  def prefix_path
+    result = FpGrowth::PrefixPath.new(count)
+    node = parent
+    while !node.is_root?
+      result << node.key
+      node = node.parent
+    end
+    result
+  end
+
+  def clone_children(new_parent)
+    @children.each do |child|
+      cloned_child = child.clone
+      cloned_child.parent = new_parent
+      new_parent.children << cloned_child
+    end
+  end
+  
+  # walks recursive through whole tree, without self
+  def each &block
+    children.each do |child|
+      block.call(child)
+      child.each(&block)
+    end
+  end
+
+  def is_root?
+    !parent
+  end
+  
+protected
+
+  def clone
+    result = FpGrowth::FpTreeNode.new(@key, @count)
+    clone_children(result)
+    result
+  end
+  
+end

data/lib/fp_growth/header_list.rb

@@ -0,0 +1,51 @@
+# Uses array as storage. Slow lookup but keeps order of items
+class FpGrowth::HeaderList
+  
+  # takes array of [key,count] or array of keys
+  def initialize(items)
+    items = items.first.respond_to?(:last) ? get_item_keys(items) : items
+    @array = items.collect { |item| FpGrowth::HeaderListNode.new(item) }
+  end
+
+  # lookup element via key
+  # if key is not found, a new element is added
+  def [](key)
+    if existing_node = @array.find { |item| item.key == key }
+      existing_node
+    else
+      new_node = FpGrowth::HeaderListNode.new(key)
+      @array << new_node
+      new_node
+    end
+  end
+  
+  # delegate to @array
+  def each(&block)
+    @array.each &block
+  end
+  
+  def each_key
+    @array.each { |node| yield(node.key) }
+  end
+  
+  def all_keys
+    @array.collect { |node| node.key }
+  end
+  
+  def to_s
+    @array.collect { |node| node.to_s }.join("\n")
+  end
+
+  # needed for cloning of fptree
+  def sort
+    @array.sort { |a, b| b.count <=> a.count }
+  end
+
+private
+
+  # takes array of [key,count]
+  # returns array of keys 
+  def get_item_keys(items)
+    items.collect { |item| item.first }
+  end
+end

data/lib/fp_growth/header_list_node.rb

@@ -0,0 +1,44 @@
+class FpGrowth::HeaderListNode
+  
+  attr_reader :key
+  
+  def initialize(key)
+    @key = key
+    @array = []
+  end
+  
+  # delegate to @array
+  def <<(tree_node)
+    @array << tree_node
+  end
+  
+  # delegate to @array
+  def each(&block)
+    @array.each &block
+  end
+  
+  # returns array of all prefix paths
+  def conditional_pattern_base
+    result = @array.collect { |tree_node| tree_node.prefix_path }
+    result.select { |pp| !pp.to_a.empty? } # strip empty ones
+  end
+
+  def conditional_fp_tree(min_support)
+    cpb = conditional_pattern_base
+    FpGrowth::FpTree.new(min_support, FpGrowth::FpTree.get_items(cpb), cpb)
+  end
+  
+  def immediate_frequent_pattern
+    FpGrowth::PrefixPath.new(count,[key])
+  end
+  
+  # TODO count could be given at initialize if known
+  def count
+    @array.inject(0) { |result, tree_node| result + tree_node.count }
+  end
+
+  def to_s
+    "#{key}:#{count} -> " << 
+    @array.collect { |tree_node| "#{tree_node.key}:#{tree_node.count}" }.join(' ')
+  end
+end

data/lib/fp_growth/inflections.rb

@@ -0,0 +1,83 @@
+class Array
+#  # slow, but nonrecursive solution
+#  def subsets_slow(include_empty = false, just_real = false)
+#    bits = size
+#    limit = 2 ** bits - 1
+#    result = []
+#    (include_empty ? 0 : 1).upto(just_real ? (limit - 1) : limit) do |count|
+#      mask = sprintf('%01$*2$b', count, bits).split(//).collect { |bit| bit == '1' }
+#      
+#      temp = []
+#      mask.each_index do |index|
+#        temp << self[index] if mask[index]
+#      end
+#      result << temp
+#    end
+#    result
+#  end
+
+  # modified from http://branch14.org/snippets/subsets_in_ruby.html
+  def subsets(include_empty = false, just_real = false, ranks = nil)
+    result = all_subsets
+    result.shift unless include_empty
+    result.pop if just_real
+    if ranks
+      result = result.select do |i|
+        if ranks.respond_to?(:include?)
+          ranks.include?(i.size)
+        else
+          ranks == i.size
+        end
+      end
+    end
+    result
+  end
+  
+  def all_subsets
+    return [[]] if empty?
+    set = clone
+    first = set.shift
+    sets = set.all_subsets
+    sets.concat(sets.collect { |s| [first] + s })
+    return sets
+  end
+  protected :all_subsets
+  
+  # TODO faster
+  def is_superset_of?(other)
+    subsets(false, true).find { |subset| other.content_equal?(subset) }
+  end
+  
+  # TODO faster
+  def is_subset_of?(other)
+    other.subsets.find { |subset| content_equal?(subset) }
+  end
+  
+  # TODO faster
+  def is_real_subset_of?(other)
+    other.subsets(false, true).find { |subset| content_equal?(subset) }
+  end
+  
+  def parts(allow_empty = false)
+    subsets(allow_empty, !allow_empty).collect do |subset|
+      [ subset, self - subset]
+    end
+  end
+  
+  def content_equal?(other)
+    return false if other.size != size
+    each do |item|
+      return false if !other.find { |other_item|
+        item.respond_to?(:content_equal?) ? item.content_equal?(other_item) : item == other_item
+      }
+    end
+    true
+  end
+end
+
+#puts [1,2].is_subset_of?([1,2]).inspect
+#puts [1,2].is_subset_of?([1,2,3]).inspect
+#puts [1,2].is_real_subset_of?([1,2]).inspect
+#puts [1,2].is_real_subset_of?([1,2,3]).inspect
+#puts [1,2,3].is_superset_of?([1,2]).inspect
+#puts [1,2].is_superset_of?([1,2]).inspect

data/lib/fp_growth/prefix_path.rb

@@ -0,0 +1,41 @@
+class FpGrowth::PrefixPath
+  
+  attr_reader :support
+  
+  def initialize(support = 1, array = [])
+    @array = array
+    @support = support
+  end
+  
+  # delegate
+  def each(&block)
+    @array.each(&block)
+  end
+  
+  # delegate
+  def <<(arg)
+    @array << arg
+  end
+  
+  #delegate
+  def size
+    @array.size
+  end
+  
+  def +(other)
+    return self unless other
+    FpGrowth::PrefixPath.new([@support, other.support].min, @array + other.to_a)
+  end
+
+  def to_s
+    "[#{@array}:#{support}]"
+  end
+  
+  def to_a
+    @array
+  end
+
+  def ==(other)
+    (support == other.support) && (to_a.content_equal?(other.to_a))
+  end
+end

data/tests/profile_fp_tree.rb

@@ -0,0 +1,24 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fp_growth'
+
+if false
+  min_support = 3
+  transactions = [
+    ['f', 'a', 'c', 'd', 'g', 'i', 'm', 'p'],
+    ['a', 'b', 'c', 'f', 'l', 'm', 'o'],
+    ['b', 'f', 'h', 'j', 'o'],
+    ['b', 'c', 'k', 's', 'p'],
+    ['a', 'f', 'c', 'e', 'l', 'p', 'm', 'n']
+  ]
+  items = FpGrowth::FpTree.get_items(transactions)
+  tree = FpGrowth::FpTree.new(min_support, items, transactions)
+else
+  tree = FpGrowth::FpTree.load
+end
+
+[:fp_growth, :fp_growth_slow].each do |m|
+  print "#{m}"
+  start = Time.now
+  100.times { tree.send(m) }
+  puts " took #{Time.now - start}s"
+end

data/tests/tc_fp_tree.rb

@@ -0,0 +1,55 @@
+class TestFpTree < Test::Unit::TestCase
+  
+  def test_file
+    assert_both_algorithms_equal FpGrowth::FpTree.load
+  end
+
+  # fails with ruby-1.8.7, ruby-1.9.1, jruby-1.3.0rc1
+  def test_something
+    transactions = [
+      [1, 2, 4, 3],
+      [1, 2, 4],
+      [1, 2],
+      [1, 3, 4],
+      [3]
+    ]
+    assert_both_algorithms_equal create_tree(2, transactions)
+  end
+
+private
+
+  def assert_both_algorithms_equal(tree)
+    frequent_patterns_right = tree.fp_growth_slow
+    frequent_patterns_wrong = tree.fp_growth
+
+#    text  = "wrong has\n" << pp_hash(generate_difference_hash frequent_patterns_wrong, frequent_patterns_right)
+#    text << "\nright has\n" << pp_hash(generate_difference_hash frequent_patterns_right, frequent_patterns_wrong)
+    assert frequent_patterns_right.content_equal?(frequent_patterns_wrong)#, text
+  end
+  
+  def pp_frequent_patterns(arg)
+    arg.collect { |a| a.to_s }.join(' ')
+  end
+
+  def create_tree(min_support, transactions)
+    FpGrowth::FpTree.new(min_support, FpGrowth::FpTree.get_items(transactions), transactions)
+  end
+
+  # result holds elements in a but not in b
+  def generate_difference_hash(a, b)
+    hash = {}
+    a.each do |item|
+      hash[item.to_a.sort] = item.support
+    end
+    b.each do |item|
+      hash.delete(item.to_a.sort) if hash[item.to_a.sort] == item.support
+    end
+    hash  
+  end
+  
+  def pp_hash(hash)
+    hash.collect { |key, value| "#{key.collect { |item| item.to_s }.join(' ')}:#{value}" }.join("\n")
+  end
+end
+
+# what is used to test equality on array - array?

data/tests/ts_all.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+begin
+  require 'rubygems'
+  require 'fp_growth'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'fp_growth'
+end
+
+
+Dir.glob(File.join(File.dirname(__FILE__), 'tc_*.rb')).each do |file|
+  require file
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: fp-growth
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Stefan Achatz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-08 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: |
+  This is an implementation of the fp-growth frequent pattern mining algorithm as
+  stated in the paper
+  
+  Mining Frequent Patterns without Candidate Generation: A Frequent-Pattern Tree Approach
+  Han et al, Data Mining and Knowledge Discovery, 8, 53-87, 2004
+
+email: stefan_achatz@web.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- examples/small_ones.rb
+- examples/cao.rb
+- lib/fp_growth.rb
+- lib/fp_growth/fp_tree.rb
+- lib/fp_growth/fp_tree_node.rb
+- lib/fp_growth/header_list.rb
+- lib/fp_growth/inflections.rb
+- lib/fp_growth/prefix_path.rb
+- lib/fp_growth/header_list_node.rb
+- tests/tc_fp_tree.rb
+- tests/profile_fp_tree.rb
+- tests/ts_all.rb
+- README
+has_rdoc: true
+homepage: http://rubyforge.org/projects/fp-growth/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- --title
+- fp-growth Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: fp-growth
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Implementation of the fp-growth frequent pattern algorithm
+test_files: 
+- tests/ts_all.rb