fpgrowth 0.0.1

data/test/tc_builder.rb

@@ -0,0 +1,65 @@
+require 'test/unit'
+require 'fpgrowth/fp_tree/builder'
+
+class TestBuilder < Test::Unit::TestCase
+
+
+  def setup
+
+    items= ['a', 'b', 'c', 'd', 'e']
+
+    r = Random.new
+
+    @n = r.rand(100..500)
+
+    @random_transactions = []
+    for i in (0..@n)
+
+
+      @m = r.rand(1..5)
+      @random_transactions[i]=[]
+      for j in (0..@m)
+        x = r.rand(10)
+        if x == 9
+          # Trick pour que le 'e' se fasse pruner
+        then
+          @random_transactions[i] << items[r.rand(items.size)]
+        else
+          @random_transactions[i] << items[r.rand(items.size - 1)]
+        end
+      end
+
+    end
+
+    @non_random = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+
+
+  end
+
+
+  def teardown
+
+  end
+
+  def test_build
+    tree = nil
+    assert_nothing_raised { tree = FpGrowth::FpTree::Builder.build(@non_random, 0.5) }
+    assert_not_nil(tree)
+    assert_instance_of(FpGrowth::FpTree::FpTree, tree)
+
+
+
+    assert_equal(nil,tree.root.item)
+    assert_equal(1, tree.root.children.size)
+    assert_equal('b', tree.root.children.first.item)
+    assert_equal('a', tree.root.children.first.children.first.item)
+    assert_equal('c', tree.root.children.first.children.last.item)
+
+    assert_nothing_raised { tree = FpGrowth::FpTree::Builder.build(@random_transactions) }
+    assert_not_nil(tree)
+    assert_instance_of(FpGrowth::FpTree::FpTree, tree)
+
+
+  end
+
+end

data/test/tc_first_pass.rb

@@ -0,0 +1,119 @@
+require 'test/unit'
+require 'fpgrowth/fp_tree/builder/first_pass'
+
+class TestFirstPass < Test::Unit::TestCase
+
+  # Generer une liste de transaction aléatoire
+  #
+  def setup
+
+    items= ['a', 'b', 'c', 'd', 'e']
+
+    r = Random.new
+
+    @n = r.rand(100..500)
+
+    @random_transactions = []
+    for i in (0..@n)
+
+
+      @m = r.rand(0..5)
+      @random_transactions[i]=[]
+      for j in (0..@m)
+        x = r.rand(21)
+        if x == 20
+          # Trick pour que le 'e' se fasse pruner
+        then
+          @random_transactions[i] << items[r.rand(items.size)]
+        else
+          @random_transactions[i] << items[r.rand(items.size - 1)]
+        end
+      end
+
+    end
+
+    #Trick pour qu'une transaction se fasse vider
+    @random_transactions << ['e']
+
+    @non_random = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+
+
+    firstPass = FpGrowth::FpTree::Builder::FirstPass.new()
+
+    @support_random = firstPass.scan(@random_transactions)
+
+    @support_non_random = firstPass.scan(@non_random)
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+  #
+  def teardown
+    # Do nothing
+  end
+
+  # test_scan
+  def test_scan
+
+    assert_equal(2, @support_non_random['a'])
+    assert_equal(4, @support_non_random['b'])
+    assert_equal(1, @support_non_random['c'])
+
+    assert_equal(5, @support_random.size)
+    for val in @support_random.values
+      assert_operator(@n * 5, ">=", val)
+    end
+  end
+
+  def test_pruning
+
+    firstPass = FpGrowth::FpTree::Builder::FirstPass.new()
+
+    random_transactions = @random_transactions.clone()
+    non_random = @non_random.clone()
+
+    @support_random_pruned = firstPass.pruning(random_transactions, @support_random.clone, 10)
+    @support_non_random_pruned = firstPass.pruning(non_random, @support_non_random.clone, 20)
+
+    # There must be no pruning, considering the very few element there is
+    assert_equal(3, @support_non_random.size, "Supports : "+@support_non_random.to_s)
+
+    minimum = @random_transactions.size.to_f / 100 * 20
+
+    assert_operator(5, ">", @support_random_pruned.size, "En plus e : #{@support_random['e']} et minimum : #{minimum}")
+    for transaction in random_transactions
+      assert_not_equal(0, transaction.size)
+      assert( not(transaction.include?('e')) , "e doit avoir disparu !")
+    end
+    assert_operator(@random_transactions.size, ">", random_transactions.size)
+  end
+
+  def test_sort
+    firstPass = FpGrowth::FpTree::Builder::FirstPass.new()
+
+    @support_random_sorted = firstPass.sort(@support_random)
+    @support_non_random_sorted = firstPass.sort(@support_non_random)
+
+    assert_equal('b', @support_non_random_sorted.keys[0])
+    assert_equal('a', @support_non_random_sorted.keys[1])
+
+    for i in (0..(@support_random_sorted.keys.size - 2))
+      assert_operator(@support_random_sorted[@support_random_sorted.keys[i]], ">=", @support_random_sorted[@support_random_sorted.keys[i+1]])
+    end
+
+  end
+
+  def test_execute
+    firstPass = FpGrowth::FpTree::Builder::FirstPass.new()
+
+    non_random_first_passed = firstPass.execute(@non_random)
+    random_first_passed = firstPass.execute(@random_transactions, 20)
+
+    assert_instance_of(Hash, non_random_first_passed)
+    assert_instance_of(Hash, random_first_passed)
+
+    assert_equal(3, non_random_first_passed.size)
+    assert_equal(4, random_first_passed.size, "En plus : #{random_first_passed}" )
+  end
+
+end

data/test/tc_fp_tree.rb

@@ -0,0 +1,168 @@
+require 'test/unit'
+require "fpgrowth/fp_tree"
+require "fpgrowth/fp_tree/node"
+require "fpgrowth/fp_tree/builder/first_pass"
+
+class TestFpTree < Test::Unit::TestCase
+
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  # test initialize
+  def test_initialize
+
+    fp_tree = nil
+    # no arguments
+    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new()}
+    assert_not_nil( fp_tree.root )
+    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
+    assert_instance_of( Hash , fp_tree.heads )
+    assert_equal( {} , fp_tree.supports )
+
+    # list empty
+    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new({})}
+    assert_not_nil( fp_tree.root )
+    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
+    assert_instance_of( Hash , fp_tree.heads )
+    assert_equal( {} , fp_tree.supports )
+
+
+    # list with arguments
+    support =  { 'a' => 1, 'b' => 2}
+    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new(support)}
+    assert_not_nil( fp_tree.root )
+    assert_instance_of( FpGrowth::FpTree::Node , fp_tree.root )
+    assert_instance_of( Hash , fp_tree.heads )
+    assert( fp_tree.heads.has_key?('a') , "a n'existe pas")
+    assert( fp_tree.heads.has_key?('b') ,"b n'existe pas !" )
+    assert_equal( 2 , fp_tree.heads.length )
+    assert( fp_tree.supports.has_key?('a') , "a n'existe pas")
+    assert( fp_tree.supports.has_key?('b') ,"b n'existe pas !" )
+    assert_equal( 2 , fp_tree.supports.length )
+
+  end
+
+  # test item_oder_lookup
+  def test_item_oder_lookup
+
+    # look up with fp_tree nul
+    fp_tree = nil
+    # no arguments
+    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new()}
+    lookup = fp_tree.item_order_lookup
+    assert_equal( {} , lookup )
+
+    # look up with fp_tree non null
+    support =  { 'a' => 1, 'b' => 2}
+    assert_nothing_raised {fp_tree = FpGrowth::FpTree::FpTree.new(support)}
+    lookup = fp_tree.item_order_lookup
+    assert_equal( 0  , lookup['a'] )
+    assert_equal( 1  , lookup['b'] )
+
+  end
+
+  # test  find_lateral_leaf_for_item
+  def test_find_lateral_leaf_for_item
+
+  end
+
+  def test_sort_children_by_support
+    @non_random = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+    @supports_non_random = FpGrowth::FpTree::Builder::FirstPass.new().execute(@non_random)
+
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    list = [FpGrowth::FpTree::Node.new('a'), FpGrowth::FpTree::Node.new('c'), FpGrowth::FpTree::Node.new('b')]
+
+
+    assert_nothing_raised { secondPass.fp_tree.sort_children_by_support(list) }
+
+
+    assert_equal(@supports_non_random.keys.first, list.first.item)
+    assert_equal(@supports_non_random.keys[1], list[1].item)
+  end
+
+
+  def test_append_node
+    parent = FpGrowth::FpTree::Node.new()
+    child = FpGrowth::FpTree::Node.new('a')
+    @non_random = [['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']]
+    @supports_non_random = FpGrowth::FpTree::Builder::FirstPass.new().execute(@non_random)
+
+
+    #Ajout first
+    secondPass = FpGrowth::FpTree::Builder::SecondPass.new(@supports_non_random)
+
+    assert_nothing_raised { secondPass.fp_tree.append_node(parent, child) }
+    assert_not_equal(0, parent.children.size)
+    assert_equal(child, parent.children.last)
+    assert_equal(child, secondPass.fp_tree.heads['a'])
+    assert_equal(parent, child.parent)
+
+    #Ajout lateral
+
+    child = FpGrowth::FpTree::Node.new('a')
+
+    assert_nothing_raised() { secondPass.fp_tree.append_node(parent, child) }
+    assert_not_equal(0, parent.children.size)
+    assert_equal(child, parent.children[1])
+    assert_equal(child, secondPass.fp_tree.heads['a'].lateral)
+
+    #Ajout en profondeur
+    parent = parent.children[0]
+
+    child = FpGrowth::FpTree::Node.new('b')
+
+    assert_nothing_raised() { secondPass.fp_tree.append_node(parent, child) }
+    assert_not_equal(0, parent.children.size)
+    assert_equal(child, parent.children[0])
+    assert_equal(child, secondPass.fp_tree.heads['b'])
+    assert_equal(parent, child.parent)
+
+    # Verifier l'ordre des enfants
+    parent = FpGrowth::FpTree::Node.new()
+    child = FpGrowth::FpTree::Node.new('a')
+    child2 = FpGrowth::FpTree::Node.new('b')
+
+
+    assert_nothing_raised() { secondPass.fp_tree.append_node(parent, child) }
+    assert_nothing_raised() { secondPass.fp_tree.append_node(parent, child2) }
+
+    assert_equal('b', parent.children.first.item)
+    assert_equal('a', parent.children.last.item)
+  end
+
+  def test_single_path
+    child = FpGrowth::FpTree::Node.new('a')
+
+    fptree = FpGrowth::FpTree.build([ ['b','a']*3])
+
+    assert_equal(true, fptree.single_path?)
+
+    fptree.append_node(fptree.root, child)
+
+    assert_equal(false, fptree.single_path?)
+
+  end
+
+  def test_combination
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c', 'a'], ['a', 'b']], 0)
+    assert_equal(true, fp_tree.single_path?)
+    power_set = nil
+    assert_nothing_raised { power_set = fp_tree.combinations }
+
+    fail("ToDo")
+
+  end
+
+end

data/test/tc_miner.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+require 'fpgrowth/miner'
+
+class TestMiner < Test::Unit::TestCase
+
+
+  def test_build_conditional_tree
+
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']], 0)
+    conditional_tree = nil
+
+
+    conditional_tree = FpGrowth::Miner.build_conditional_tree(fp_tree, 'a')
+
+    fp_tree.graphviz()
+    conditional_tree.graphviz("conditional")
+
+
+    assert_equal('b', conditional_tree.root.children.first.item)
+    assert_equal(2, conditional_tree.root.children.first.support)
+    assert_equal([], conditional_tree.root.children.first.children)
+
+    assert_equal(true, conditional_tree.single_path?)
+
+    items= ['a', 'b', 'c', 'd', 'e']
+
+    # Randomized
+
+    r = Random.new
+    @n = r.rand(100..500)
+    @random_transactions = []
+    for i in (0..@n)
+
+
+      @m = r.rand(0..5)
+      @random_transactions[i]=[]
+      for j in (0..@m)
+        x = r.rand(21)
+        if x == 20
+          # Trick pour que le 'e' se fasse pruner
+        then
+          @random_transactions[i] << items[r.rand(items.size)]
+        else
+          @random_transactions[i] << items[r.rand(items.size - 1)]
+        end
+      end
+
+    end
+
+    #Trick pour qu'une transaction se fasse vider
+    @random_transactions << ['e']
+
+    fp_tree = FpGrowth::FpTree.build(@random_transactions, 1)
+    conditional_tree = FpGrowth::Miner.build_conditional_tree(fp_tree, fp_tree.heads.keys[-2])
+
+    fp_tree.graphviz()
+    conditional_tree.graphviz("conditional-#{fp_tree.heads.keys[-2]}")
+
+  end
+
+  def test_fp_growth
+    fp_tree = FpGrowth::FpTree.build([['a', 'b'], ['b'], ['b', 'c'], ['a', 'b']], 0)
+    pattern_set = nil
+
+    assert_nothing_raised { pattern_set = FpGrowth::Miner.fp_growth(fp_tree) }
+    assert_not_equal(0, pattern_set.size)
+
+
+
+  end
+
+  def fp_growth_randomized
+    # Randomized
+
+    items= ['a', 'b', 'c', 'd', 'e', 'f','g','h','i','j','k']
+    r = Random.new
+    @n = r.rand(100..500)
+    @random_transactions = []
+    for i in (0..@n)
+
+
+      @m = r.rand(0..5)
+      @random_transactions[i]=[]
+      for j in (0..@m)
+        x = r.rand(21)
+        if x == 20
+          # Trick pour que le 'e' se fasse pruner
+        then
+          @random_transactions[i] << items[r.rand(items.size)]
+        else
+          @random_transactions[i] << items[r.rand(items.size - 1)]
+        end
+      end
+
+    end
+
+    #Trick pour qu'une transaction se fasse vider
+    @random_transactions << ['e']
+
+    fp_tree = FpGrowth::FpTree.build(@random_transactions, 10)
+    pattern_set = nil
+
+    assert_nothing_raised { pattern_set = FpGrowth::Miner.fp_growth(fp_tree) }
+    assert_not_equal(0, pattern_set.size)
+
+
+    for pattern in pattern_set
+      puts "<#{pattern.content}:#{pattern.support}>"
+    end
+
+
+
+    fail("ToDo")
+  end
+
+end