RubyGems - rrlist - Versions diffs - 0.0.1 - Mend

rrlist 0.0.1

Files changed (38) hide show

data/.gitignore +7 -0
data/Gemfile +5 -0
data/README.md +158 -0
data/Rakefile +1 -0
data/doc/RRArchive.html +555 -0
data/doc/RRComposite.html +639 -0
data/doc/RRList/Functions.html +675 -0
data/doc/RRList/List.html +2277 -0
data/doc/RRList/Stores.html +115 -0
data/doc/RRList/Stores/InMemoryArray.html +609 -0
data/doc/RRListStore.html +115 -0
data/doc/RRListStore/InMemoryArray.html +580 -0
data/doc/RRMath.html +634 -0
data/doc/RRlist.html +131 -0
data/doc/_index.html +170 -0
data/doc/class_list.html +53 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +57 -0
data/doc/css/style.css +338 -0
data/doc/file.README.html +227 -0
data/doc/file_list.html +55 -0
data/doc/frames.html +28 -0
data/doc/index.html +227 -0
data/doc/js/app.js +214 -0
data/doc/js/full_list.js +178 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +268 -0
data/doc/top-level-namespace.html +112 -0
data/lib/rrlist.rb +3 -0
data/lib/rrlist/functions.rb +80 -0
data/lib/rrlist/list.rb +212 -0
data/lib/rrlist/stores.rb +45 -0
data/lib/rrlist/version.rb +3 -0
data/rrlist.gemspec +27 -0
data/spec/lib/rrlist/functions_spec.rb +19 -0
data/spec/lib/rrlist/list_spec.rb +416 -0
data/spec/spec_helper.rb +36 -0
metadata +167 -0

@@ -0,0 +1,112 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.8.6.1
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  hasFrames = window.top.frames.main ? true : false;
+  relpath = '';
+  framesUrl = "frames.html#!" + escape(window.location.href);
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+      Class List
+    </a>
+    <a class="full_list_link" id="method_list_link"
+        href="method_list.html">
+      Method List
+    </a>
+    <a class="full_list_link" id="file_list_link"
+        href="file_list.html">
+      File List
+    </a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="RRList.html" title="RRList (module)">RRList</a></span>
+</p>
+</div>
+    <div id="footer">
+  Generated on Fri May 31 08:53:01 2013 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.8.6.1 (ruby-1.9.2).
+</div>
+  </body>
+</html>

data/lib/rrlist.rb ADDED

@@ -0,0 +1,3 @@
+require File.expand_path('../rrlist/version', __FILE__)
+require File.expand_path('../rrlist/functions', __FILE__)
+require File.expand_path('../rrlist/list', __FILE__)

data/lib/rrlist/functions.rb ADDED

@@ -0,0 +1,80 @@
+module RRList
+  # @author Federico Dayan
+  # A helper module that provides some Proc object to be use with RRList::List
+  # @example
+  #   RRList::List.new :size => 10, :range => 5, &RRList::Functions.max
+  #   RRList::List.new :size => 10, :range => 5, &RRList::Functions.incr
+  module Functions
+    # @return [Proc] A proc to be used in a RRList::List that calculates the average of the values inserted at and index
+    def self.avg
+      Proc.new do |index, old_value, new_value|
+        case new_value
+          when Hash
+            if old_value
+              {
+                value: RRList::Functions.calc_average(old_value[:size],old_value[:value],new_value[:value],new_value[:size]),
+                size: old_value[:size] + new_value[:size]
+              }
+            else
+              {
+                value: new_value[:value],
+                size: new_value[:size],
+              }
+            end
+          else
+             if old_value
+              {
+                value: RRList::Functions.calc_average(old_value[:size],old_value[:value],new_value),
+                size: old_value[:size] + 1
+              }
+            else
+              {
+                value: new_value,
+                size: 1,
+              }
+            end
+         end
+      end
+    end
+    # @return [Proc] A proc to be used in a RRList::List that calculates the max of the values inserted at and index
+    def self.max
+      Proc.new do |index, old_value, new_value|
+        old_value.nil? || (new_value > old_value) ? new_value : old_value
+      end
+    end
+    # @return [Proc] A proc to be used in a RRList::List that calculates the min of the values inserted at and index
+    def self.min
+      Proc.new do |index, old_value, new_value|
+        old_value.nil? || (new_value < old_value) ? new_value : old_value
+      end
+    end
+    # @return [Proc] A proc to be used in a RRList::List increments the values inserted at and index
+    def self.incr
+      Proc.new do |index, old_value, new_value|
+        old_value ? (old_value + new_value) : new_value
+      end
+    end
+    # @return [Proc] A proc to be used in a RRList::List decrements the values inserted at and index
+    def self.decr
+      Proc.new do |index, old_value, new_value|
+        old_value ? (old_value - new_value) : new_value
+      end
+    end
+    private
+      def self.calc_average(numbers,previous_average,add_average,add_numbers=1)
+        numbers = numbers.to_f
+        previous_average = previous_average.to_f
+        add_average = add_average.to_f
+        (((numbers*previous_average )+ (add_average*add_numbers))/(numbers+add_numbers))
+      end
+  end
+end

data/lib/rrlist/list.rb ADDED

@@ -0,0 +1,212 @@
+require File.expand_path('../stores', __FILE__)
+module RRList
+  # @author Federico Dayan
+  # Represents a Round Robin List.
+  # You set the max number of items and the size does not increse. While you add more items you lose the older items
+  class List
+    # Creates an object
+    # @param options [Hash]
+    # @option options [Integer] :size The size of the list. It does not add more elements than this.
+    # @option options [Integer] :range The range of the list. A range of 5 group 5 indexes into one position.
+    # @option options [Integer] :store Represents the where we save the data. It must follow a contract (see RRList:Stores:InMemoryArray)
+    # @yield [index, old_value, new_value]
+    def initialize(options={},&function_proc)
+      raise ":size is required" unless options[:size]
+      raise ":range should be greater thant 0" if options[:range] &&  options[:range] < 1
+      @store = options[:store] || RRList::Stores::InMemoryArray.new
+      @size = options[:size].to_i
+      @range = options[:range] || 1
+      reset
+      @function_proc = function_proc if block_given?
+    end
+    # Sets all values to nil, but it does not move the cursor
+    def clear
+       @store.fill(nil,0...@size)
+    end
+    # Reset this list, set all values to nil and move cursor to position 0
+    def reset
+      clear
+      @position = 0
+      @current_index = 0
+    end
+    # @return [Array<Integer>] The min_index and max_index as a list
+    def ranges
+      return [min_index,max_index]
+    end
+    # @param index [Integer] A number
+    # @return [True] if the given number is in the limits of the current max an min index of the list
+    def in_limits?(index)
+      ( !higher?(index) && !lower?(index))
+    end
+    # @param index [Integer] A number
+    # @return [True] if the given number is out of the range and all numbers will be lost if set
+    def out_of_range?(index) # refactor to out of limits?
+      if in_limits?(index)
+        return false
+      elsif higher?(index)
+        (index - max_index) >= (@size*@range)
+      elsif lower?(index)
+        (min_index - index) >= (@size*@range)
+      end
+    end
+    # @param index [Integer] A number
+    # @return [True] if the giving number is higher that the current max index.
+    def higher?(index)
+      index > (max_index + remaining_in_slot)
+    end
+    # @param index [Integer] A number
+    # @return [True] if the giving number is lower that the current min index.
+    def lower?(index)
+      index < min_index
+    end
+    # Iterates of over the values. Expects a block and passes the value
+    def each(&blk)
+      values.each(&blk)
+    end
+    # Iterates of over the values. Expects a block and passes the value and index
+    def each_with_index
+      ordered_values = values
+      ordered_values.each_with_index do |v,i|
+        yield ordered_values[i], min_index + (i*@range)
+      end
+    end
+    # @return [Object] the value for the specified index
+    def get(index)
+      return nil unless in_limits?(index)
+      pos = ((index/@range) % @size)
+      @store.get(pos)
+    end
+    # Adds a value to the next index position and moves the cursor forward
+    # @param value any object
+    def add(value)
+      @add_at_next = 0 unless @add_at_next
+      add_at @add_at_next, value
+    end
+    # Add an item to the specified postion and set the cursor to that position
+    # @param index must be higher than max_index
+    # @param value any object
+    def add_at(index,value)
+      raise "Index is lower that current index" if index < max_index
+      @add_at_next = index + 1
+      pos = position_for_index(index)
+      if out_of_range?(index)
+        @store.fill_with_nils
+      elsif higher?(index)
+        (pos-1).downto(@position) { |i| @store.put(i,nil) } if @current_index >= @size
+        @store.put(pos,nil) # We clean the value, if not it gets used by @before_add
+      end
+      set_value(pos,value)
+      @position = pos + 1
+      @current_index = index
+      self
+    end
+    # Set the specified value in the given index. The index must be in the range.
+    def set_at(index, value)
+      raise "The index #{index} is not in the range of the list" unless in_limits?(index)
+      pos = position_for_index(index)
+      set_value(pos,value)
+    end
+    # @return [Integer] if range is used, returns the remaining numbers in the current position.
+    def remaining_in_slot
+      (@range - (max_index % @range)) - 1
+    end
+    # @return [Integer] the index size of this list
+    def index_size
+      @size*@range
+    end
+    # @return [Integer] The min index of the current list
+    def min_index
+      if max_index <= index_size
+        0
+      else
+        (max_index + 1) - index_size + remaining_in_slot
+      end
+    end
+    # @return [Integer] the max indes of current list
+    def max_index
+      @current_index
+    end
+    # @return [Array<Object>] The values of this list
+    def values
+      ret = if @current_index < (@size*@range)
+              @store.raw
+            else
+              @store.start_at(@position)
+            end
+      return ret
+    end
+    # Pretty print this object
+    def to_s
+      values.to_s
+    end
+    #########################
+    #   Array API
+    #########################
+    # Returns the value for the given index
+    # @see #get
+    def [](index)
+      get(index)
+    end
+    # Sets a value to in the given index.
+    # @see #add_at
+    def []=(index,value)
+      add_at(index,value)
+    end
+    # Adds a value to the end of the list.
+    # @see #add
+    def << value
+      add(value)
+    end
+   private
+    def position_for_index(index)
+      ((index/@range) % @size)
+    end
+    def set_value(index,val,update_position=true)
+      if @function_proc
+        adding = @function_proc.call(index,@store.get(index),val)
+        @store.put(index, adding)
+      else
+        @store.put(index,val)
+      end
+    end
+  end
+end

data/lib/rrlist/stores.rb ADDED

@@ -0,0 +1,45 @@
+module RRList
+  module Stores
+    # @author Federico Dayan
+    # An implementation of a store that follows the contract
+    class InMemoryArray
+      def initialize
+        @values = []
+      end
+      def set_values(values)
+        @values = values
+      end
+      def put(index,value)
+        @values[index] = value
+        nil
+      end
+      def get(index)
+        @values[index]
+      end
+      def fill_with_nils
+        @values.fill(nil)
+        nil
+      end
+      def fill(value, range)
+        @values.fill(value,range)
+        nil
+      end
+      def raw
+        @values
+      end
+      def start_at(position)
+        @values[position..@values.size] + @values[0...position]
+      end
+    end
+  end
+end