algorithms 0.2.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/spec/kd_tree_spec.rb CHANGED
@@ -1,4 +1,34 @@
1
1
  $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
2
2
  require 'algorithms'
3
3
 
4
- # TODO: KD Tree Spec
4
+ describe Containers::KDTree do
5
+ it "should work for a documented example" do
6
+ kdtree = Containers::KDTree.new( {0 => [4, 3], 1 => [3, 0], 2 => [-1, 2], 3 => [6, 4],
7
+ 4 => [3, -5], 5 => [-2, -5] })
8
+ closest_2 = kdtree.find_nearest([0, 0], 2)
9
+ expect(closest_2).to eql([[5, 2], [9, 1]])
10
+ end
11
+
12
+ it "should work for real-life example from facebook puzzle" do
13
+ points = {}
14
+ input = File.open(File.join(File.dirname(__FILE__), 'kd_test_in.txt'), 'r')
15
+
16
+ # Populate points hash
17
+ input.each_line do |line|
18
+ break if line.empty?
19
+ n, x, y = line.split(/\s+/)
20
+ points[n.to_i] = [x.to_f, y.to_f]
21
+ end
22
+
23
+ out = ""
24
+ kdtree = Containers::KDTree.new(points)
25
+ points.sort{ |(k1, v1), (k2, v2)| k1 <=> k2 }.each { |id, point|
26
+ nearest_4 = kdtree.find_nearest(point, 4)
27
+ out << "#{id} #{nearest_4[1..-1].collect{ |n| n[1] }.join(',')}\n"
28
+ }
29
+
30
+ expected = File.read(File.join(File.dirname(__FILE__), 'kd_expected_out.txt'))
31
+ expect(expected).to eql(out)
32
+ end
33
+
34
+ end
@@ -1,8 +1,8 @@
1
1
  $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
2
2
  require 'algorithms'
3
3
 
4
- if defined? Containers::CRBTreeMap
5
- describe "CRBTreeMap" do
4
+ if !(defined? RUBY_ENGINE && RUBY_ENGINE == 'jruby')
5
+ describe "map gc mark test" do
6
6
  it "should mark ruby object references" do
7
7
  anon_key_class = Class.new do
8
8
  attr :value
@@ -10,16 +10,20 @@ if defined? Containers::CRBTreeMap
10
10
  def <=>(other); value <=> other.value; end
11
11
  end
12
12
  anon_val_class = Class.new
13
- @tree = Containers::CRBTreeMap.new
14
- 100.times { |x| @tree[anon_key_class.new(x)] = anon_val_class.new }
13
+ @rbtree = Containers::RBTreeMap.new
14
+ @splaytree = Containers::SplayTreeMap.new
15
+ 100.times { |x|
16
+ @rbtree[anon_key_class.new(x)] = anon_val_class.new
17
+ @splaytree[anon_key_class.new(x)] = anon_val_class.new
18
+ }
15
19
  # Mark and sweep
16
20
  ObjectSpace.garbage_collect
17
21
  # Check if any instances were swept
18
22
  count = 0
19
23
  ObjectSpace.each_object(anon_key_class) { |x| count += 1 }
20
- count.should eql(100)
24
+ expect(count).to eql(200)
21
25
  ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
22
- count.should eql(200)
26
+ expect(count).to eql(400)
23
27
  end
24
28
  end
25
29
  end
@@ -8,32 +8,32 @@ describe Containers::PriorityQueue do
8
8
 
9
9
  describe "(empty priority queue)" do
10
10
  it "should return 0 for size and be empty" do
11
- @q.size.should eql(0)
12
- @q.should be_empty
11
+ expect(@q.size).to eql(0)
12
+ expect(@q).to be_empty
13
13
  end
14
14
 
15
15
  it "should not return anything" do
16
- @q.next.should be_nil
17
- @q.pop.should be_nil
18
- @q.delete(1).should be_nil
19
- @q.has_priority?(1).should be_false
16
+ expect(@q.next).to be_nil
17
+ expect(@q.pop).to be_nil
18
+ expect(@q.delete(1)).to be_nil
19
+ expect(@q.has_priority?(1)).to be false
20
20
  end
21
21
 
22
22
  it "should give the correct size when adding items" do
23
23
  20.times do |i|
24
- @q.size.should eql(i)
24
+ expect(@q.size).to eql(i)
25
25
  @q.push(i, i)
26
26
  end
27
27
  10.times do |i|
28
- @q.size.should eql(20-i)
28
+ expect(@q.size).to eql(20-i)
29
29
  @q.pop
30
30
  end
31
31
  10.times do |i|
32
- @q.size.should eql(i+10)
32
+ expect(@q.size).to eql(i+10)
33
33
  @q.push(i, i)
34
34
  end
35
35
  @q.delete(5)
36
- @q.size.should eql(19)
36
+ expect(@q.size).to eql(19)
37
37
  end
38
38
  end
39
39
 
@@ -45,31 +45,31 @@ describe Containers::PriorityQueue do
45
45
  end
46
46
 
47
47
  it "should next/pop the highest priority" do
48
- @q.next.should eql("Alaska")
49
- @q.size.should eql(3)
50
- @q.pop.should eql("Alaska")
51
- @q.size.should eql(2)
48
+ expect(@q.next).to eql("Alaska")
49
+ expect(@q.size).to eql(3)
50
+ expect(@q.pop).to eql("Alaska")
51
+ expect(@q.size).to eql(2)
52
52
  end
53
53
 
54
54
  it "should not be empty" do
55
- @q.should_not be_empty
55
+ expect(@q).not_to be_empty
56
56
  end
57
57
 
58
58
  it "should has_priority? priorities it has" do
59
- @q.has_priority?(50).should be_true
60
- @q.has_priority?(10).should be_false
59
+ expect(@q.has_priority?(50)).to be true
60
+ expect(@q.has_priority?(10)).to be false
61
61
  end
62
62
 
63
63
  it "should return nil after popping everything" do
64
64
  3.times do
65
65
  @q.pop
66
66
  end
67
- @q.pop.should be_nil
67
+ expect(@q.pop).to be_nil
68
68
  end
69
69
 
70
70
  it "should delete things it has and not things it doesn't" do
71
- @q.delete(50).should eql("Alaska")
72
- @q.delete(10).should eql(nil)
71
+ expect(@q.delete(50)).to eql("Alaska")
72
+ expect(@q.delete(10)).to eql(nil)
73
73
  end
74
74
  end
75
75
  end
data/spec/queue_spec.rb CHANGED
@@ -8,20 +8,20 @@ describe "empty queue" do
8
8
 
9
9
 
10
10
  it "should return nil when sent #pop" do
11
- @queue.pop.should be_nil
11
+ expect(@queue.pop).to be_nil
12
12
  end
13
13
 
14
14
  it "should return a size of 1 when sent #push" do
15
15
  @queue.push(1)
16
- @queue.size.should eql(1)
16
+ expect(@queue.size).to eql(1)
17
17
  end
18
18
 
19
19
  it "should return nil when sent #next" do
20
- @queue.next.should be_nil
20
+ expect(@queue.next).to be_nil
21
21
  end
22
22
 
23
23
  it "should return empty?" do
24
- @queue.empty?.should be_true
24
+ expect(@queue.empty?).to be true
25
25
  end
26
26
  end
27
27
 
@@ -33,29 +33,29 @@ describe "non-empty queue" do
33
33
  end
34
34
 
35
35
  it "should return first pushed object" do
36
- @queue.pop.should eql(10)
36
+ expect(@queue.pop).to eql(10)
37
37
  end
38
38
 
39
39
  it "should return the size" do
40
- @queue.size.should eql(2)
40
+ expect(@queue.size).to eql(2)
41
41
  end
42
42
 
43
43
  it "should not return empty?" do
44
- @queue.empty?.should be_false
44
+ expect(@queue.empty?).to be false
45
45
  end
46
46
 
47
47
  it "should iterate in FIFO order" do
48
48
  arr = []
49
49
  @queue.each { |obj| arr << obj }
50
- arr.should eql([10, "10"])
50
+ expect(arr).to eql([10, "10"])
51
51
  end
52
52
 
53
53
  it "should return nil after all gets" do
54
54
  2.times do
55
55
  @queue.pop
56
56
  end
57
- @queue.pop.should be_nil
58
- @queue.next.should be_nil
57
+ expect(@queue.pop).to be_nil
58
+ expect(@queue.next).to be_nil
59
59
  end
60
60
 
61
61
  end
@@ -1,37 +1,37 @@
1
1
  $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
2
2
  require 'algorithms'
3
3
 
4
- describe "empty rbtree", :shared => true do
4
+ shared_examples "empty rbtree" do
5
5
  it "should let you push stuff in" do
6
6
  100.times { |x| @tree[x] = x }
7
- @tree.size.should eql(100)
7
+ expect(@tree.size).to eql(100)
8
8
  end
9
9
 
10
10
  it "should be empty?" do
11
- @tree.empty?.should be_true
11
+ expect(@tree.empty?).to be true
12
12
  end
13
13
 
14
14
  it "should return 0 for height" do
15
- @tree.height.should eql(0)
15
+ expect(@tree.height).to eql(0)
16
16
  end
17
17
 
18
18
  it "should return 0 for size" do
19
- @tree.size.should eql(0)
19
+ expect(@tree.size).to eql(0)
20
20
  end
21
21
 
22
22
  it "should return nil for max and min" do
23
- @tree.min.should be_nil
24
- @tree.max.should be_nil
25
- @tree.min_key.should be_nil
26
- @tree.max_key.should be_nil
23
+ expect(@tree.min).to be_nil
24
+ expect(@tree.max).to be_nil
25
+ expect(@tree.min_key).to be_nil
26
+ expect(@tree.max_key).to be_nil
27
27
  end
28
28
 
29
29
  it "should not delete" do
30
- @tree.delete(:non_existing).should be_nil
30
+ expect(@tree.delete(:non_existing)).to be_nil
31
31
  end
32
32
  end
33
33
 
34
- describe "non-empty rbtree", :shared => true do
34
+ shared_examples "non-empty rbtree" do
35
35
  before(:each) do
36
36
  @num_items = 1000
37
37
  @random_array = Array.new(@num_items) { rand(@num_items) }
@@ -39,52 +39,52 @@ describe "non-empty rbtree", :shared => true do
39
39
  end
40
40
 
41
41
  it "should return correct size (uniqify items first)" do
42
- @tree.should_not be_empty
43
- @tree.size.should eql(@random_array.uniq.size)
42
+ expect(@tree).not_to be_empty
43
+ expect(@tree.size).to eql(@random_array.uniq.size)
44
44
  end
45
45
 
46
46
  it "should return correct max and min" do
47
- @tree.min_key.should eql(@random_array.min)
48
- @tree.max_key.should eql(@random_array.max)
49
- @tree.min[0].should eql(@random_array.min)
50
- @tree.max[0].should eql(@random_array.max)
47
+ expect(@tree.min_key).to eql(@random_array.min)
48
+ expect(@tree.max_key).to eql(@random_array.max)
49
+ expect(@tree.min[0]).to eql(@random_array.min)
50
+ expect(@tree.max[0]).to eql(@random_array.max)
51
51
  end
52
52
 
53
53
  it "should not #has_key? keys it doesn't have" do
54
- @tree.has_key?(100000).should be_false
54
+ expect(@tree.has_key?(100000)).to be false
55
55
  end
56
56
 
57
57
  it "should #has_key? keys it does have" do
58
- @tree.has_key?(@random_array[0]).should be_true
58
+ expect(@tree.has_key?(@random_array[0])).to be true
59
59
  end
60
60
 
61
61
  it "should remove all keys" do
62
62
  ordered = []
63
63
  @random_array.uniq.each do |key|
64
- @tree.has_key?(key).should eql(true)
64
+ expect(@tree.has_key?(key)).to eql(true)
65
65
  ordered << @tree.delete(key)
66
- @tree.has_key?(key).should eql(false)
66
+ expect(@tree.has_key?(key)).to eql(false)
67
67
  end
68
- ordered.should eql(@random_array.uniq)
68
+ expect(ordered).to eql(@random_array.uniq)
69
69
  end
70
70
 
71
71
  it "should delete_min keys correctly" do
72
72
  ascending = []
73
73
  ascending << @tree.delete_min until @tree.empty?
74
- ascending.should eql(@random_array.uniq.sort)
74
+ expect(ascending).to eql(@random_array.uniq.sort)
75
75
  end
76
76
 
77
77
  it "should delete_max keys correctly" do
78
78
  descending = []
79
79
  descending << @tree.delete_max until @tree.empty?
80
- descending.should eql(@random_array.uniq.sort.reverse)
80
+ expect(descending).to eql(@random_array.uniq.sort.reverse)
81
81
  end
82
82
 
83
83
  it "should let you iterate with #each" do
84
84
  counter = 0
85
85
  sorted_array = @random_array.uniq.sort
86
86
  @tree.each do |key, val|
87
- key.should eql(sorted_array[counter])
87
+ expect(key).to eql(sorted_array[counter])
88
88
  counter += 1
89
89
  end
90
90
  end
data/spec/search_spec.rb CHANGED
@@ -8,21 +8,21 @@ describe "search algorithms" do
8
8
  n = 1000
9
9
  @rand_array = Array.new(n) { rand(n) }.sort
10
10
 
11
- Algorithms::Search.binary_search(@rand_array, @rand_array.first).should eql(@rand_array.first)
12
- Algorithms::Search.binary_search(@rand_array, 999999).should be_nil
13
- Algorithms::Search.binary_search(@rand_array, nil).should be_nil
11
+ expect(Algorithms::Search.binary_search(@rand_array, @rand_array.first)).to eql(@rand_array.first)
12
+ expect(Algorithms::Search.binary_search(@rand_array, 999999)).to be_nil
13
+ expect(Algorithms::Search.binary_search(@rand_array, nil)).to be_nil
14
14
  end
15
15
 
16
16
  it "should use kmp_search to find substrings it has" do
17
17
  string = "ABC ABCDAB ABCDABCDABDE"
18
- Algorithms::Search.kmp_search(string, "ABCDABD").should eql(15)
19
- Algorithms::Search.kmp_search(string, "ABCDEF").should be_nil
20
- Algorithms::Search.kmp_search(string, nil).should be_nil
21
- Algorithms::Search.kmp_search(string, "").should be_nil
22
- Algorithms::Search.kmp_search(nil, "ABCD").should be_nil
18
+ expect(Algorithms::Search.kmp_search(string, "ABCDABD")).to eql(15)
19
+ expect(Algorithms::Search.kmp_search(string, "ABCDEF")).to be_nil
20
+ expect(Algorithms::Search.kmp_search(string, nil)).to be_nil
21
+ expect(Algorithms::Search.kmp_search(string, "")).to be_nil
22
+ expect(Algorithms::Search.kmp_search(nil, "ABCD")).to be_nil
23
23
  end
24
24
 
25
25
  it "should let you include Search in String to enable instance methods" do
26
- "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD").should eql(15)
26
+ expect("ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD")).to eql(15)
27
27
  end
28
28
  end
data/spec/sort_spec.rb CHANGED
@@ -4,17 +4,18 @@ include Algorithms
4
4
 
5
5
  describe "sort algorithms" do
6
6
  before(:each) do
7
- @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort shell_sort quicksort mergesort)
7
+ @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort
8
+ shell_sort quicksort mergesort dualpivotquicksort)
8
9
  end
9
10
 
10
11
  it "should work for empty containers" do
11
12
  empty_array = []
12
- @sorts.each { |sort| Sort.send(sort, empty_array).should eql([]) }
13
+ @sorts.each { |sort| expect(Sort.send(sort, empty_array)).to eql([]) }
13
14
  end
14
15
 
15
16
  it "should work for a container of size 1" do
16
17
  one_array = [1]
17
- @sorts.each { |sort| Sort.send(sort, one_array).should eql(one_array) }
18
+ @sorts.each { |sort| expect(Sort.send(sort, one_array)).to eql([1]) }
18
19
  end
19
20
 
20
21
  it "should work for random arrays of numbers" do
@@ -22,7 +23,7 @@ describe "sort algorithms" do
22
23
  rand_array = Array.new(n) { rand(n) }
23
24
  sorted_array = rand_array.sort
24
25
 
25
- @sorts.each { |sort| Sort.send(sort, rand_array.dup).should eql(sorted_array) }
26
+ @sorts.each { |sort| expect(Sort.send(sort, rand_array.dup)).to eql(sorted_array) }
26
27
  end
27
28
 
28
- end
29
+ end
@@ -1,27 +1,31 @@
1
1
  $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
2
2
  require 'algorithms'
3
3
 
4
- describe "empty splaytree", :shared => true do
4
+ shared_examples "empty splaytree" do
5
5
  it "should let you push stuff in" do
6
6
  100.times { |x| @tree[x] = x }
7
- @tree.size.should eql(100)
7
+ expect(@tree.size).to eql(100)
8
8
  end
9
9
 
10
10
  it "should return 0 for size" do
11
- @tree.size.should eql(0)
11
+ expect(@tree.size).to eql(0)
12
12
  end
13
13
 
14
14
  it "should return nil for #min and #max" do
15
- @tree.min.should be_nil
16
- @tree.max.should be_nil
15
+ expect(@tree.min).to be_nil
16
+ expect(@tree.max).to be_nil
17
17
  end
18
18
 
19
19
  it "should return nil for #delete" do
20
- @tree.delete(:non_existing).should be_nil
20
+ expect(@tree.delete(:non_existing)).to be_nil
21
+ end
22
+
23
+ it "should return nil for #get" do
24
+ expect(@tree[4235]).to be_nil
21
25
  end
22
26
  end
23
27
 
24
- describe "non-empty splaytree", :shared => true do
28
+ shared_examples "non-empty splaytree" do
25
29
  before(:each) do
26
30
  @num_items = 100
27
31
  @random_array = []
@@ -30,40 +34,40 @@ describe "non-empty splaytree", :shared => true do
30
34
  end
31
35
 
32
36
  it "should return correct size (uniqify items first)" do
33
- @tree.size.should eql(@random_array.uniq.size)
37
+ expect(@tree.size).to eql(@random_array.uniq.size)
34
38
  end
35
39
 
36
40
  it "should have correct height (worst case is when items are inserted in order, and height = num items inserted)" do
37
41
  @tree.clear
38
42
  10.times { |x| @tree[x] = x }
39
- @tree.height.should eql(10)
43
+ expect(@tree.height).to eql(10)
40
44
  end
41
45
 
42
46
  it "should return correct max and min keys" do
43
- @tree.min[0].should eql(@random_array.min)
44
- @tree.max[0].should eql(@random_array.max)
47
+ expect(@tree.min[0]).to eql(@random_array.min)
48
+ expect(@tree.max[0]).to eql(@random_array.max)
45
49
  end
46
50
 
47
51
  it "should not #has_key? keys it doesn't have" do
48
- @tree.has_key?(10000).should be_false
52
+ expect(@tree.has_key?(10000)).to be false
49
53
  end
50
54
 
51
55
  it "should #has_key? keys it does have" do
52
- @tree.has_key?(@random_array[0]).should be_true
56
+ expect(@tree.has_key?(@random_array[0])).to be true
53
57
  end
54
58
 
55
59
  it "should remove any key" do
56
60
  random_key = @random_array[rand(@num_items)]
57
- @tree.has_key?(random_key).should be_true
58
- @tree.delete(random_key).should eql(random_key)
59
- @tree.has_key?(random_key).should be_false
61
+ expect(@tree.has_key?(random_key)).to be true
62
+ expect(@tree.delete(random_key)).to eql(random_key)
63
+ expect(@tree.has_key?(random_key)).to be false
60
64
  end
61
65
 
62
66
  it "should let you iterate with #each" do
63
67
  counter = 0
64
68
  sorted_array = @random_array.uniq.sort
65
69
  @tree.each do |key, val|
66
- key.should eql(sorted_array[counter])
70
+ expect(key).to eql(sorted_array[counter])
67
71
  counter += 1
68
72
  end
69
73
  end