ds 0.0.4 → 0.0.6

data/lib/ds/graphs/graph_as_tri_matrix.rb

@@ -1,24 +0,0 @@
-module DS
-  class GraphAsTriMatrix < GraphAsMatrix
-
-    def initialize(edges)
-      @store = TriMatrix.new(0)
-      @max = 0
-      @map = OrderedSet.new
-
-      add_edges(edges)
-    end
-
-    #Returns vertex degree.  
-    def degree(x)
-      x = @map.index(x)
-      sum = 0
-      0.upto @max do |i|
-        sum += @store[x,i] if @store[x,i] 
-      end
-      sum
-    end
-
-  end
-end
-

data/lib/ds/lists/cyclic_list.rb

@@ -1,21 +0,0 @@
-module DS
-
-  #Class represent list with cycle.
-  class CyclicList < List
-
-    #Returns cycle size. If list has no cycles returns 0.
-    def cycle_size
-      counter = 0
-      if start = self.joint
-        counter = 1
-        elem = joint.next
-        while elem != start
-          elem = elem.next
-          counter += 1
-        end
-      end
-      counter
-    end
-
-  end
-end

data/lib/ds/lists/ring.rb

@@ -1,42 +0,0 @@
-module DS
-  
-  #Ring - represent list which head is linked with tail.
-  class Ring < CyclicList
-
-    #Creates ring from array. 
-    def self.from_array(arr)
-      list = Ring.new(arr.shift)
-      tail = list.head
-      arr.each { |e| tail = tail.append(e) }
-      tail.next = list.head
-      list
-    end
-
-    def length
-      cycle_size
-    end
-
-    #Removes ring elements by k until there is only one element in list.
-    def eliminate_by(k)
-      elem = self.head
-      prev = elem
-
-      k = k-1
-
-      while prev != elem.next 
-
-        k.times  do
-          prev = elem
-          elem = elem.next
-        end
-
-        prev.next = elem.next
-        elem = prev.next
-      end
-
-      return prev.data
-
-    end
-
-  end
-end

data/lib/ds/matrixes/expandable_array.rb

@@ -1,37 +0,0 @@
-module DS
-  
-  #Class provides access to any element in array. If index i 
-  #is greter than array size then elements from size to i are
-  #filled with extender.
-  class ExpandableArray < Array
-    def initialize(size=0,extender=0)
-      @extender = extender
-      super(size,extender)
-    end
-
-    #Returns element at index. If index is greater than size of array then
-    #elements from size to index are filled with extender.
-    def [](x)
-      if x >=size
-        for i in size..x
-          self[i]=@extender
-        end
-      end
-      super(x)
-    end
-
-    #Sets the element at index. If index is greater than size of array then
-    #elements from size to index are filled with extender.
-    def []=(x,v)
-      max = size
-      super(x,v)
-      if size - max >1
-        (max..size-2).each do |i|
-          self[i] = @extender
-        end
-      end
-    end
-  end
-end
-
-

data/lib/ds/matrixes/tri_matrix.rb

@@ -1,30 +0,0 @@
-module DS
-  class TriMatrix
-
-    #Class implements Triangular Matrix (lower).
-
-    #Creates new triangular matrix.  
-    def initialize(init=0)
-      @store =ExpandableArray.new(0,init)
-    end
-
-    #Returns element at index x,y (or y,x).
-    def [](x,y)
-      x,y = y,x if y > x
-      index = (x*x+x)/2 +y
-      @store[index]
-    end
-
-    #Sets the element at index x,y (or y,x).
-    def []=(x,y,v)
-      x,y = y,x if y>x
-      index = (x*x+x)/2 +y
-      @store[index] = v
-    end
-
-    def to_a
-      @store
-    end
-
-  end
-end

data/lib/ds/queues/queue.rb

@@ -1,53 +0,0 @@
-module DS
-  
-  #Class implements queue data structure.
-  
-  class Queue
-
-    #Create new queue. First parameter determines how the queue will be represented internally.
-    def initialize(store = :array)
-      if store == :array 
-        @store = []
-      else
-        @store = List.new
-      end
-    end
-    
-    #Create new queue. Internaly uses list to store elements.
-    def Queue.create
-      new(:list)
-    end
-    
-    #Adds element to queue and returns queue itself.
-    def enqueue(x)
-      @store << x
-      self
-    end
-
-    alias :push :enqueue
-    
-    #Removes element from queue and returns it.
-    def dequeue
-      @store.shift
-    end
-
-    alias :shift :dequeue
-  
-    #Returns element from forehead of queue.
-    def peek
-      @store.first
-    end
-
-    #Returns length of queue. If queue is empty returns 0.
-    def length
-      @store.length
-    end
-    
-    #Checks if queue is empty.
-    def empty?
-      @store.empty?
-    end
-
-  end
-end
-

data/lib/ds/sets/ordered_set.rb

@@ -1,32 +0,0 @@
-module DS
-  class OrderedSet
-    attr_reader :size
-
-    #Creates new Ordered Set.
-    def initialize
-      @size = 0
-      @store = {}
-    end
-
-    #Adds new element to set
-    def push e
-      if index = @store[e]
-        index
-      else
-        @size = @size+1
-        @store[e] = @size-1
-      end
-    end
-
-    #Returns element index.
-    def index e
-      @store[e]
-    end
-
-    def to_a
-      @store.sort{|a,b| a[1]<=>b[1]}.map{|e| e.first}
-    end
-
-
-  end
-end

data/lib/ds/trees/binary_search_tree.rb

@@ -1,34 +0,0 @@
-module DS
-  class BinarySearchTree < BinaryTree
-
-    #Creates new search tree from array.
-    def self.from_array(arr)
-      tree = BinarySearchTree.new(arr.shift)
-      arr.each do |e|
-        tree.insert e
-      end
-      tree
-    end
-
-    #Inserts new element.
-    def insert x
-      if x > @data and right.nil?
-        self.right = BinarySearchTree.new(x)
-      elsif x <= @data and left.nil?
-        self.left = BinarySearchTree.new(x)
-      elsif x > @data
-        right.insert x
-      else
-        left.insert x
-      end
-    end
-
-    #Checks if tree is valid Binary Search Tree.
-    def BinarySearchTree.valid?(other)
-      walker = TreeWalker.new(other)
-      walker.traverse(:inorder)
-      walker.visited.extend(ArrayX).sorted?
-    end
-
-  end
-end

data/lib/ds/trees/complete_binary_tree.rb

@@ -1,60 +0,0 @@
-module DS
-  class CompleteBinaryTree
-   
-    #Creates new tree (stored in array).
-    def initialize(*args)
-      if args.empty? 
-        @data = []
-      else
-        @data = args.to_a
-      end
-    end
-
-    #Inserts new element.
-    def << (value)
-      @data.push value
-    end
-
-    #Returns root element.
-    def root
-      @data.first
-    end
-
-    #Returns index of left child.
-    def left_index(i)
-      2*i+1  
-    end
-
-    #Returns index of right child.
-    def right_index(i)
-      2*i+2
-    end
-
-    #Returns index of parent.
-    def parent_index(i)
-      (i+1)/2 - 1
-    end
-
-    #Returns children of node i.
-    def children(i)
-      [@data[left_index(i)], @data[right_index(i)]]
-    end
-
-    #Returns left child of node i.
-    def left(i)
-      @data[left_index(i)]
-    end
-
-    #Returns left child of node i.
-    def right(i)
-      @data[right_index(i)]
-    end
-
-    #Returns parent of node i.
-    def parent(i)
-      @data[parent_index(i)]
-    end
-
-  end
-end
-

data/test/test_array_x.rb

@@ -1,51 +0,0 @@
-require 'help'
-
-describe ArrayX do
-
-  before do
-    @asc = [1,3,6,9,10,13].extend(ArrayX)
-    @desc = [9,8,7,7,4,3,2].extend(ArrayX)
-    @short = [1,2].extend(ArrayX)
-
-    @empty = [].extend(ArrayX)
-    @one = [3].extend(ArrayX)
-    @not_sorted = [3,4,9,1,1,2,8].extend(ArrayX)
-  end
-
-  it "#sorted? should check if array is already sorted." do
-    assert @desc.sorted?
-    assert @asc.sorted?
-    assert @empty.sorted?
-    assert @one.sorted?
-    assert @short.sorted? 
-    refute @not_sorted.sorted?
-    assert @desc.sorted?(:desc)
-    refute @desc.sorted?(:asc)
-    assert @asc.sorted?(:asc)
-    refute @asc.sorted?(:desc)
-    refute @not_sorted.sorted?(:des)
-    refute @not_sorted.sorted?(:asc)
-    assert @short.sorted?(:asc)
-    refute @short.sorted?(:desc)
-    
-    assert @one.sorted?(:asc)
-    assert @one.sorted?(:asc)
-
-  end
-  
-  it "#duplications? should check if array has duplicates." do
-    refute @asc.duplications?
-    assert @desc.duplications?
-    assert @not_sorted.duplications?
-    refute @empty.duplications?
-  end
-
-  it "#tail should return array without first element." do
-    @asc.tail.must_equal [3,6,9,10,13]
-    @short.tail.must_equal [2]
-    @one.tail.must_equal []
-    @empty.tail.must_be_nil
-  end
-end
-
-

data/test/test_binary_search_tree.rb

@@ -1,39 +0,0 @@
-require 'help'
-
-describe BinarySearchTree do
-
-  before do
-
-
-    t = BinarySearchTree.new(7)
-    c1 = t.insert 5
-    c2 = t.insert 8
-
-    c3 = c1.insert 2
-    c1.insert 6
-
-    c3.insert 1
-
-    @bst = t
-
-    @bin_tree = BinaryTree.new
-    [2,5,8,9,11,12,14].each{|x| @bin_tree.insert(x)}
-    
-  end
-
-  it "should be valid  Binary Search Tree." do
-    assert BinarySearchTree.valid?(@bst)
-  end
-
-  it "#from_array should create new valid BinarySearchTree." do
-    b = BinarySearchTree.from_array([8,1,5,2,7,6,3])
-    assert BinarySearchTree.valid?(b)
-    TreeWalker.new(b).traverse(:inorder).must_equal [1,2,3,5,6,7,8]
-  end
-
-  it "not every Binary Tree is valid Binary Search Tree." do
-    refute BinarySearchTree.valid?(@bin_tree)
-  end
-
-end
- 

data/test/test_complete_binary_tree.rb

@@ -1,58 +0,0 @@
-require 'help'
-
-describe CompleteBinaryTree do
-
-  before do
-    @tree = CompleteBinaryTree.new(1,2,3,4,5,6,7)
-    @empty_tree = CompleteBinaryTree.new
-  end
-
-  it "#<< should add new element." do
-    @empty_tree << 1
-    @empty_tree << 2
-    @empty_tree.root.must_equal 1
-  end
-
-  it "#root should return root of the tree." do
-    @tree.root.must_equal 1
-  end
-
-  it "#left_index should return index of left child" do
-    @tree.left_index(0).must_equal 1
-    @tree.left_index(1).must_equal 3
-  end
-
-  it "#right_index should return index of left child" do
-    @tree.right_index(0).must_equal 2
-    @tree.right_index(1).must_equal 4
-  end
-
-  it "#parent_index should return index of left child" do
-    @tree.parent_index(1).must_equal 0
-    @tree.parent_index(3).must_equal 1
-  end
-
-  it "#left should return left child" do
-    @tree.left(0).must_equal 2
-    @tree.left(1).must_equal 4
-  end
-
-  it "#right should return right child" do
-    @tree.right(0).must_equal 3
-    @tree.right(1).must_equal 5
-  end
-
-  it "#parent should return parent." do
-    @tree.parent(3).must_equal 2
-    @tree.parent(4).must_equal 2
-    @tree.parent(1).must_equal 1
-  end
-
-  it "#children should return children." do
-    @tree.children(0).must_equal [2,3]
-  end
-
-
-
-end
-