RubyGems - rrlist - Versions diffs - 0.0.1 - Mend

rrlist 0.0.1

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.

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

data/doc/top-level-namespace.html ADDED

@@ -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