is103 1.2

data/lib/is103.rb

@@ -0,0 +1,3 @@
+autoload :GraphLab,       "graphlab.rb"
+autoload :LinearDSLab,       "lineardslab.rb"
+autoload :TreeLab,       "treelab.rb"

data/lib/lineardslab.rb

@@ -0,0 +1,395 @@
+module RubyLabs
+
+module LinearDSLab
+	
+	#VERSION 1.2
+	#Labelled top and bottom of stack, front and end of queue
+	#Added a line after Lab title
+	
+	# A Struct is a convenient way to bundle a number of attributes together, using accessor methods, without having to write an explicit class. This StackView object is being used to store the location of all the rectangles, and its corresponding values.
+	StackView = Struct.new(:cells, :values)
+	
+	# Generates the view for a stack visualization
+	def view_stack(s, *peek)
+		# Initializes the canvas and font type
+		Canvas.init(400, 400, "Stack")
+		Canvas::Font.new('bucketfont', :family => 'Helvetica', :size => 11)
+		
+		stack = s.items
+
+		cells = []
+		values = []
+		
+		# Define starting height of first rectangle
+		y0 = 50
+		Canvas::Text.new("Stack Lab", 10, 1, {:font => :bucketfont})
+		Canvas::Line.new(0, 20, 400, 20, :fill => :gray, :width => 1)
+		
+		# If generating a peek view, color first rectangle red, and place it on the right
+		if peek[0] && stack[0]
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[0].fill = 'red'
+			y1 = y0+3
+			values << Canvas::Text.new(stack[0], 65, y0+3, {:font => :bucketfont})
+			Canvas::Text.new("<- Top of the Stack", 200, y1, {:font => :bucketfont})
+			
+		# Else place a normal rectangle
+		elsif stack[0]
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[0].fill = 'grey'
+			y1 = y0+3
+			values << Canvas::Text.new(stack[0], 65, y0+3, {:font => :bucketfont})
+			Canvas::Text.new("<- Top of the Stack", 200, y1, {:font => :bucketfont})
+		end
+		
+		iterations = stack.length-1
+		
+		# Iterate as many times as the number of elements in the array minus one. The first element is already handled above.
+		iterations.times do |i|
+			y0 += 25
+			# Draw a rectangle and store a reference to this rectangle in the cells array
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[i+1].fill = 'grey'
+			# Draw the text value and store a reference to this value in the values array
+			values << Canvas::Text.new(stack[i+1], 65, y0+3, {:font => :bucketfont})
+		end
+		
+		if stack.length-1 > 0
+			Canvas::Text.new("<- Bottom of the Stack", 200, y0+3, {:font => :bucketfont})
+		end	
+			
+		# Store the properties of this drawing as a Struct object
+		s.drawing = StackView.new(cells, values)
+		return true
+	end
+	  
+	# Ruby Array-based implementation of a Stack
+	class Stack
+		
+		# array used to store the values in the stack
+		attr_reader :items
+		# Struct object to store the attributes of the drawn visualization
+		attr_accessor :drawing
+		
+		# class constructor
+		def initialize
+			@items = Array.new
+		end
+		
+		# pop method. if a drawing exists, redraw the canvas
+		def pop
+			value = items.shift
+			if @drawing
+				view_stack(self, false)
+			end
+			return value
+		end
+		
+		# peek method. if a drawing exists, redraw the canvas
+		def peek
+			if @drawing
+				view_stack(self, true)
+			end
+			return items.first
+		end
+		
+		# push method. if a drawing exists, redraw the canvas
+		def push(value)
+			output = items.unshift(value)
+			if @drawing
+				view_stack(self, false)
+			end
+			return output
+		end
+		
+		# return a string representation of the array
+		def inspect
+			return to_s
+		end
+		
+		# returns a string representation of the array
+		def to_s	
+			return @items.inspect
+		end
+
+		# returns the number of items currently in the stack
+		def count
+			return items.count
+		end
+	end
+
+	# A Struct is a convenient way to bundle a number of attributes together, using accessor methods, without having to write an explicit class. This QueueView object is being used to store the location of all the rectangles, and its corresponding values.
+	QueueView = Struct.new(:cells, :values)
+	
+	# Generates the view for a queue visualization
+	def view_queue(q, *peek)
+		# Initializes the canvas and font type
+		Canvas.init(400, 400, "Queue")
+		Canvas::Font.new('bucketfont', :family => 'Helvetica', :size => 11)
+		
+		queue = q.items
+
+		cells = []
+		values = []
+		
+		# Define starting height of first rectangle
+		y0 = 50
+		Canvas::Text.new("Queue Lab", 10, 1, {:font => :bucketfont})
+		Canvas::Line.new(0, 20, 400, 20, :fill => :gray, :width => 1)
+		
+		# If generating a peek view, color last rectangle red, and place it on the right
+		if peek[0] && queue[0]
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[0].fill = 'red'
+			y1 = y0+3
+			values << Canvas::Text.new(queue[0], 65, y1, {:font => :bucketfont})
+			Canvas::Text.new("<- Head of the Queue", 200, y1, {:font => :bucketfont})
+			
+		# Else place a normal rectangle
+		elsif queue[0]
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[0].fill = 'grey'
+			y1 = y0+3
+			values << Canvas::Text.new(queue[0], 65, y1, {:font => :bucketfont})
+			Canvas::Text.new("<- Head of the Queue", 200, y1, {:font => :bucketfont})
+		end
+		
+		iterations = queue.length-1
+		
+		# Iterate as many times as the number of elements in the array minus one. The first element is already handled above.
+		iterations.times do |i|
+			y0 += 25
+			# Draw a rectangle and store a reference to this rectangle in the cells array
+			cells << Canvas::Rectangle.new(10, y0, 60, y0+25)
+			cells[i+1].fill = 'grey'
+			# Draw the text value and store a reference to this value in the values array
+			values << Canvas::Text.new(queue[i+1], 65, y0+3, {:font => :bucketfont})
+		end
+		
+		if queue.length-1 > 0
+			Canvas::Text.new("<- Tail of the Queue", 200, y0+3,{:font => :bucketfont})
+		end	
+			
+		# Store the properties of this drawing as a Struct object
+		q.drawing = QueueView.new(cells, values)
+		return true
+	end
+	  
+	# Ruby Array-based implementation of a queue
+	class Queue
+		
+		# array used to store the values in the queue
+		attr_reader :items
+		# Struct object to store the attributes of the drawn visualization
+		attr_accessor :drawing
+		
+		# class constructor
+		def initialize
+			@items = Array.new
+		end
+		
+		# dequeue method. if a drawing exists, redraw the canvas
+		def dequeue
+			value = items.shift
+			if @drawing
+				view_queue(self, false)
+			end
+			return value
+		end
+		
+		# peek method. if a drawing exists, redraw the canvas
+		def peek
+			if @drawing
+				view_queue(self, true)
+			end
+			return items.first
+		end
+		
+		# enqueue method. if a drawing exists, redraw the canvas
+		def enqueue(value)
+			output = items << value
+			if @drawing
+				view_queue(self, false)
+			end
+			return output
+		end
+		
+		# enqueue method. an alternative.
+		def <<(value)
+			output = items << value
+			if @drawing
+				view_queue(self, false)
+			end
+			return output
+		end
+
+		# dequeue method. an alternative.
+		def shift
+			value = items.shift
+			if @drawing
+				view_queue(self, false)
+			end
+			return value
+		end
+
+		# return a string representation of the array
+		def inspect
+			return to_s
+		end
+		
+		# returns a string representation of the array
+		def to_s	
+			return @items.inspect
+		end
+
+		# returns the number of items currently in the queue
+		def count
+			return items.count
+		end	
+	end
+
+	# checks whether an array is a palindrome using both stack and queue
+	# :begin :is_palindrome
+	def is_palindrome(v)
+		t = v.split(//)
+		q = Queue.new
+		s = Stack.new
+		t.each { |x| q.enqueue(x) }			
+		t.each { |x| s.push(x) }			
+		while s.count > 0
+			left = q.dequeue
+			right = s.pop			
+			return false if(left != right)
+		end
+		return true
+	end
+	# :end :is_palindrome
+
+	# checks whether an array contains balanced braces using stack
+	# :begin :check_braces
+	def check_braces(t)
+	  s = Stack.new
+	  balancedSoFar = true
+	  i = 0
+	  while i < t.count and balancedSoFar
+	    if t[i] == "{"
+	      s.push(t[i])
+	    elsif t[i] == "}"
+	      if s.count > 0
+	        s.pop
+	      else
+	        balancedSoFar = false
+	      end
+	    end		
+	    i += 1
+	  end
+	  return (balancedSoFar and s.count==0)
+	end
+	# :end :check_braces
+	
+	# :begin :fibonacci_stack
+	def fibonacci_stack(n)
+	  s = Stack.new
+	  s.push(n)
+	  result = 0
+	  while s.count > 0
+	    current = s.pop
+	    if current == 0
+	      result += 0
+	    elsif current == 1
+	      result += 1
+	    else
+	      s.push(current - 2)
+	      s.push(current - 1)
+	    end
+	  end
+	  return result
+	end
+	# :end :fibonacci_stack
+	
+	# :begin :fibonacci
+	def fibonacci(n)
+	  if n == 0
+	    return 0
+	  elsif n == 1
+	    return 1
+	  else
+	    return fibonacci(n-1) + fibonacci(n-2)
+	  end
+	end
+	# :end :fibonacci
+	
+	# recursive version of binary search (from Conery's book)
+	# :begin :rbsearch
+	def rbsearch(a, k, lower = -1, upper = a.length)
+	  mid = (lower + upper)/2
+	  return nil if upper == lower + 1
+	  return mid if k == a[mid]
+	   
+	  if k < a[mid]
+	    return rbsearch(a, k, lower, mid)
+	  else
+	  	return rbsearch(a, k, mid, upper)
+	  end
+	end
+	# :end :rbsearch
+	
+	# non-recursive, stack-based version of binary searh
+	# :begin :rbsearch_stack
+	def rbsearch_stack(a, k, lower = -1, upper = a.length)
+	  s = Stack.new
+	  s.push(lower)
+	  s.push(upper)  
+	  while s.count > 0
+	  	upper = s.pop
+	  	lower = s.pop  	
+	  	mid = (lower + upper)/ 2
+	  	return nil if upper == lower + 1
+	  	return mid if k == a[mid]  	
+	  	if k < a[mid]
+	  		s.push(lower)
+	  		s.push(mid)
+	  	else
+	  		s.push(mid)
+	  		s.push(upper)
+	  	end
+	  end
+	end
+	# :end :rbsearch_stack
+
+	# This brackets method is taken from RubyLabs.
+	# A helper method that can be called from a probe to display the contents
+	# of an array during a search or sort.  See also IterationLab#brackets.
+	#
+	# The version implemented in this module accepts an additional argument,
+	# which specifies the location of the right bracket in the output string
+	# (if this argument is not give the right bracket is inserted at the end).
+	#
+	# An optional third argument, intended for experiments with binary search, tells
+	# the method where to insert an asterisk before an item.
+	#
+	# Examples:
+	#
+	#   >> a = TestArray.new(15)
+	#   => [22, 3, 70, 74, 35, 0, 82, 64, 90, 54, 88, 26, 75, 18, 17]
+	#   >> puts brackets(a, 8, 10)
+	#    22  3  70  74  35  0  82  64 [90  54  88] 26  75  18  17
+	#   => nil
+	#   >> puts brackets(a, 8, 10, 9)
+	#    22  3  70  74  35  0  82  64 [90 *54  88] 26  75  18  17
+	#   => nil
+	#
+	  def brackets(a, left, right = a.length-1, mid = nil)
+	    left = 0 if left < 0
+	    right = a.length-1 if right >= a.length
+	    pre = left == 0 ? "" : " " + a.slice(0..(left-1)).join("  ") + " "
+	    inner = left <= right ? a.slice(left..right).join("  ") : ""
+	    post = " " + a.slice(right+1..-1).join("  ")
+	    res = pre + "[" + inner + "]" + post
+	    if mid && left < right
+	      res[res.index(a[mid].to_s)-1] = ?*
+	    end
+	    return res
+	  end
+	end
+end 

data/lib/treelab.rb

@@ -0,0 +1,418 @@
+module TreeLab
+    
+    #    Version 1.2    (27/09/2012)
+    #    Changelog
+    #        1.    Created Binary Search Tree class
+    #
+    #    Version 1.1    (08/08/2012)
+    #    Changelog
+    #        1.    Changed node.leftChild to node.left, and node.rightChild to node.right
+    #        2.    Merged preorder_traversal(*speed), inorder_traversal(*speed), postorder_traversal(*speed) into traversal(tree, option, *speed), where valid options are preorder, inorder, and postorder
+    #        3.    Display text at end of traversal to indicate visit order: "Visited 9, 6, 5, 4"
+    #        4.    Display order number during traversal
+    #        5.    Tree animation now freezes at last frame
+    #
+    #    Version  1.0    (06/08/2012)
+    #    Changelog
+    #        1.    Created Binary Tree, Node classes to represent a binary tree and a tree node
+    #        2.    Created view_tree to visualize the tree and preorder_traversal, inorder_traversal, postorder_traversal to animate the traversal of a tree
+        
+    @@tree = nil
+    @@visited = nil
+    @@sleep = 0.5
+    
+    def view_tree(tree)
+        @@tree = tree
+        raise "Value must be a BinaryTree!" if !(tree.class == TreeLab::BinaryTree || tree.class == TreeLab::BinarySearchTree)
+        # Initializes the canvas and font type
+        Canvas.init(30+(2**tree.heightOfTree)*30, 50*tree.heightOfTree+50, "TreeLab")
+        Canvas::Font.new('bucketfont', :family => 'Helvetica', :size => 10)
+
+        # calls recursive method to draw the tree using post-order traversal
+        if tree.root == nil
+            return true
+        end
+        preOrder(tree.root, ((2**tree.heightOfTree)*30)/2, 30, ((2**tree.heightOfTree)*30)/2)
+        return true
+    end
+    
+    def tree
+        @@tree
+    end
+    
+    def traversal(tree, option, *speed)
+        view_tree(tree)
+        if (!speed[0])
+            @@sleep = 0.5
+        else
+            @@sleep = speed[0]
+        end
+        
+        Canvas::Font.new('bucketfont', :family => 'Helvetica', :size => 10)
+
+        @@visited = Array.new
+        
+        root = @@tree.root
+        sleep(1)
+        case option
+        when :preorder
+            preorder_traverse(root)
+        when :inorder
+            inorder_traverse(root)
+        when :postorder
+            postorder_traverse(root)
+        else
+            return "Invalid option. Valid options include :preorder, :inorder, :postorder"
+        end
+        sleep(1)
+        
+        text = "Visited: "
+        
+        @@visited.each_with_index {
+            |val, index| 
+            text = text + val.to_s
+            if index != @@visited.length-1
+                text = text + ", "
+            end
+        }
+        return text
+    end
+    
+    # Ruby Reference-based implementation of a Binary Tree
+    class BinaryTree
+        
+        # root node
+        attr_reader :root
+        
+        # class constructor
+        def initialize()
+        end
+        
+        def setRoot(node)
+            raise "Value must be a Node!" if node.class != TreeLab::Node
+            raise "cannot attach node to itself" if node == self
+            @root = node
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+            return to_s
+        end
+        
+        # checks whether the tree is empty
+        def isEmpty?
+            return root == nil
+        end
+        
+        # counts number of nodes in the tree
+        def noOfNodes
+            if @root == nil
+                return 0
+            end
+            return countNode(@root)
+        end
+        
+        # counts the height of the tree
+        def heightOfTree
+            if (@root == nil)
+                return 0
+            else
+                return countHeight(@root)
+            end
+        end
+        
+        # empties the tree
+        def empty
+            @root = nil
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+            return true
+        end
+        
+        def inspect
+            return to_s
+        end
+        
+        #    returns string representation of root node
+        def to_s
+            return nil if @root == nil
+            return @root.to_s
+        end
+                    
+        private
+        #    private recursive method to count the number of nodes
+        def countNode(node)
+            if (node == nil)
+                return 0
+            end
+            if (node.isLeaf?)
+                return 1
+            end
+            return 1 + countNode(node.left) + countNode(node.right)
+        end
+        
+        #    private recursive method to count the height of the tree
+        def countHeight(node)
+            if (node == nil)
+                return 0
+            end
+            if (node.isLeaf?)
+                return 1
+            end
+            return 1 + [countHeight(node.left),countHeight(node.right)].max
+        end        
+    end
+    
+    #    Node class used to represent each node in a binary tree
+    class Node
+    
+        # left child of node
+        attr_reader:left
+        # right child of node
+        attr_reader:right
+        # value of node
+        attr_accessor:value
+        # attribute that represents the node in a binary tree canvas
+        attr_accessor:circle
+        
+        def initialize(value)
+            @value = value
+        end 
+        
+        #    sets the left child node
+        def setLeft(node)
+            raise "Value must be a Node!" if node.class != TreeLab::Node
+            raise "cannot attach node to itself" if node == self
+            raise "left child is not empty" if @left != nil
+            @left = node
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+            return to_s
+        end
+        
+        #    sets the right child node
+        def setRight(node)
+            raise "Value must be a Node!" if node.class != TreeLab::Node
+            raise "cannot attach node to itself" if node == self
+            raise "left child is not empty" if @right != nil
+            @right = node
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+            return to_s
+        end
+        
+        #    deletes the left child node
+        def delLeft
+            @left = nil
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+        end
+        
+        #    deletes the left child node
+        def delRight
+            @right = nil
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+        end
+        
+        #    checks whether this node is a leaf node
+        def isLeaf?
+            return (left == nil && right == nil);
+        end
+        
+        # return a string representation of the node
+        def inspect
+            return to_s
+        end
+        
+        # returns a string representation of the node
+        def to_s    
+            s = "Value: "+value.to_s;
+            if (left != nil)
+                s += ", left child: "+left.value.to_s;
+            else
+                s += ", left child: nil"
+            end
+            if (right != nil)
+                s += ", right child: "+right.value.to_s;
+            else
+                s += ", right child: nil"
+            end
+            return s;
+        end
+    end
+    
+    class BinarySearchTree < BinaryTree
+        
+        # :begin :search
+        def search(key)
+            if !stable
+                p "Warning! Binary Search tree is not sorted correctly."
+            end
+            if(TreeLab::tree)
+                @@visited = Array.new
+                view_tree(self)
+                bstsearch(@root, key)
+            end
+            return searchbst(@root, key)
+        end
+        # :end :search
+        
+        # :begin :insert
+        def insert(key)
+            if !stable
+                p "Warning! Binary Search tree is not sorted correctly."
+            end
+            if(TreeLab::tree) 
+                @@visited = Array.new
+                view_tree(self)
+                bstsearch(@root, key)
+            end
+            node = insertbst(@root, key)
+            if(TreeLab::tree) 
+                view_tree(TreeLab::tree)
+            end
+            
+            return node
+        end
+        # :end :insert
+        
+        def stable
+            @@stableChecker = Array.new
+            inorder_check(@root)
+            
+            for i in 1..@@stableChecker.length-1
+                return false if @@stableChecker[i] < @@stableChecker[i-1]
+            end
+            return true
+        end
+        
+        private
+        
+        def inorder_check(root)
+            if (root != nil) 
+                inorder_check(root.left)
+                @@stableChecker << root.value
+                inorder_check(root.right)
+            end
+        end
+
+        # :begin :insertbst
+        def insertbst(root, key)
+            if root.value == key
+                return root
+            elsif root.value > key
+                if root.left != nil
+                    return insertbst(root.left, key)
+                else
+                    node = Node.new(key)
+                    root.setLeft(node)
+                    return node
+                end
+            else
+                if root.right != nil
+                    return insertbst(root.right, key)
+                else
+                    node = Node.new(key)
+                    root.setRight(node)
+                    return node
+                end
+            end
+        end
+        # :end :insertbst
+        
+        # :begin :searchbst
+        def searchbst(root, key)
+            if root.value == key
+                return root
+            elsif root.left != nil and root.value > key
+                return searchbst(root.left, key)
+            elsif root.right != nil and root.value < key
+                return searchbst(root.right, key)
+            else
+                return nil
+            end
+        end
+        # :end :searchbst
+    end
+    
+    private
+    
+    #private recursive method to draw the tree
+    def preOrder(t, x, y, width)
+        if (t != nil)
+            t.circle = Canvas::Circle.new(x, y, 15)
+            Canvas::Text.new(t.value, x, y, :anchor => :center)
+            if (t.left != nil)
+                Canvas::Line.new(x-15, y, x-(width/2), y+50-15)
+            end
+            preOrder(t.left, x-(width/2), y+50, width/2)
+            if (t.right != nil)
+                Canvas::Line.new(x+15, y, x+(width/2), y+50-15)
+            end
+            preOrder(t.right, x+(width/2), y+50, width/2)
+        end
+    end
+
+    #    :begin :preorder_traverse
+    def preorder_traverse(node)
+        if (node != nil) 
+            visit(node)
+            preorder_traverse(node.left)
+            preorder_traverse(node.right)
+        end
+    end
+    #    :end :preorder_traverse
+    
+    #    :begin :postorder_traverse
+    def postorder_traverse(node)
+        if (node != nil) 
+            postorder_traverse(node.left)
+            postorder_traverse(node.right)
+            visit(node)
+        end
+    end
+    #    :end :postorder_traverse
+    
+    #    :begin :inorder_traverse
+    def inorder_traverse(node)
+        if (node != nil) 
+            inorder_traverse(node.left)
+            visit(node)
+            inorder_traverse(node.right)
+        end
+    end
+    #    :end :inorder_traverse
+    
+    def bstsearch(node, val)
+        if (node != nil) 
+            visit(node)
+            if (val == node.value)
+                
+            elsif (val < node.value)
+                bstsearch(node.left, val)
+            else
+                bstsearch(node.right, val)
+            end
+        end
+    end
+    
+    #    :begin :visit
+    def visit(node)
+        @@visited << node.value
+        Canvas::Text.new(@@visited.length, node.circle.coords[0]+11, node.circle.coords[1]+33, :font => 'bucketfont')
+        node.circle.fill = 'red'
+        sleep(@@sleep)
+        node.circle.fill = 'green'
+    end
+    #    :end :visit
+    
+    def updateVisitedText(value)
+        if (value == nil)
+        end
+    end
+end