rubyonacid 0.1.2 → 0.2.0

data/README.textile

@@ -1,21 +1,89 @@
 !http://github.com/jaymcgavren/rubyonacid/raw/master/generators.png!
 
+
 h1. Ruby On Acid
 
-A Ruby library for making trippy visuals.
+A Ruby library for making trippy visuals and sounds.  Need to pick locations and colors to draw in?  Let one of Ruby On Acid's "factories" do it for you.  Then swap out one factory for another without changing your code.  Need to pick a note from a scale or a tempo?  Ruby On Acid factories can do that too.  And if none of the bundled factories does what you need, it's easy to write your own.
+
+
+h1. Installation
 
+<pre>
+  sudo gem install rubyonacid
+</pre>
 
-h1. Factories
+
+h1. Using Factories
 
 The factory is the core concept of Ruby On Acid.  You create a factory of a particular type, and then anywhere in your code that you need a value within a certain range, you get it from the factory.  For example, if you need x and y coordinates for drawing on a 800 x 600 window, you would tell a factory that you need a value for :x from 0 to 800, and a value for :y from 0 to 600.  If you later wanted to change drawing patterns, you could simply swap out factories.
 
+<pre>
+  def draw(factory)
+    window.draw_circle(
+      factory.get(:x, :max => 800),
+      factory.get(:y, :max => 600),
+      factory.get(:radius, :max => 100)
+    )
+  end
+  
+  current_factory = RubyOnAcid::RandomFactory.new
+  10.times {draw(current_factory)}
+  current_factory = RubyOnAcid::LoopFactory.new
+  10.times {draw(current_factory)}
+</pre>
+
+See the examples directory for usage of the various factories.
+
+
+h1. Writing Your Own Factories
+
+Making new factories is easy - simply make a subclass of RubyOnAcid::Factory.  Then write a get_unit() method that takes a key and returns a value between 0 and 1.
+
+For example, here's the entire code for the bundled RandomFactory class:
+
+<pre>
+  class RandomFactory < RubyOnAcid::Factory
+    def get_unit(key)
+      return rand
+    end
+  end
+</pre>
+
+Of course, when the values you're generating are random, you don't need to know what they'll be used for.  For situations where you do care, you can use the "key" parameter, which is an indication from the factory user of the kind of value they need.  This class tracks the previously returned value for a key and increments the next one:
+
+<pre>
+  class CumulativeFactory < RubyOnAcid::Factory
+    def initialize
+      super #Be sure to call Factory's constructor if you override it!
+      @counters = Hash.new {|h, k| h[k] = 0.0}
+    end
+    def get_unit(key)
+      @counters[key] = (@counters[key] + 0.1) % 1.0
+      return @counters[key]
+    end
+  end
+
+  factory = CumulativeFactory.new
+  puts factory.get(:x) # => 0.1
+  puts factory.get(:y) # => 0.1
+  puts factory.get(:x) # => 0.2
+  puts factory.get(:z) # => 0.1
+</pre>
+
+Start by looking at the code for the bundled factories in the lib/rubyonacid/factories directory; it should give you some ideas of what's possible.
+
+
+h1. Resources
+
+The project page on GitHub lets you browse the latest code, or clone or fork the source repo for yourself.
+
+"GitHub project":http://www.github.com/jaymcgavren/rubyonacid
 
-h1. Roadmap
+The discussion list is the place for questions, problems, bug reports, feature requests, etc.  And since working with Ruby On Acid is usually a creative endeavor, be sure to share your ideas and learn from others, too!
 
-* A factory that evaluates the last value for 2 keys and modifies a third based on them.  (Example, change the size of rectangles based on their x and y coordinates.
-* Skip Factory: Add probability matrix [0.5, 0.9, 0.1...] that causes get_unit() to return true every time rand() is > given value. Also add mask value (0.1, 0.9), etc, that is added to random value to increase likelihood of returning true.
+"Discussion list":http://groups.google.com/group/rubyonacid
 
 
 h1. Copyright
 
-Copyright (c) 2009 Jay McGavren. See LICENSE for details.
+Copyright (c) 2009 Jay McGavren. Released under the MIT license. See the LICENSE file for details.

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/examples/ascii.rb

@@ -0,0 +1,45 @@
+#This method takes any Factory and uses it to determine the length of lines to print.
+def make_lines(factory)
+  #Show what factory we're working with.
+  puts factory.class.name
+  10.times do
+    #Get the length of the line.
+    #The :max option scales the returned length to be between 0 and 79.
+    line_length = factory.get(:length, :max => 79)
+    puts "|" * line_length
+  end
+end
+
+#Random factories generate a random number between 0 and 1.
+require 'rubyonacid/factories/random'
+make_lines RubyOnAcid::RandomFactory.new
+
+#Loop factories loop from 0 to 1 (or 1 to 0 if the increment value is negative).
+require 'rubyonacid/factories/loop'
+make_lines RubyOnAcid::LoopFactory.new(0.2)
+make_lines RubyOnAcid::LoopFactory.new(-0.2)
+
+#Constant factories always return the same value,
+require 'rubyonacid/factories/constant'
+make_lines RubyOnAcid::ConstantFactory.new(0.5)
+
+#This flash factory returns 0 twice, then 1 twice, then 0 twice, etc.
+require 'rubyonacid/factories/flash'
+make_lines RubyOnAcid::FlashFactory.new(2)
+
+#Sine factories produce a "wave" pattern.
+require 'rubyonacid/factories/sine'
+make_lines RubyOnAcid::SineFactory.new(0.3)
+
+#A RepeatFactory wraps another factory, queries it, and repeats the same value a certain number of times.
+require 'rubyonacid/factories/repeat'
+factory_to_repeat = RubyOnAcid::LoopFactory.new(0.3)
+make_lines RubyOnAcid::RepeatFactory.new(factory_to_repeat, 2)
+
+#A CombinationFactory combines the values of two or more other factories.
+require 'rubyonacid/factories/combination'
+factories_to_combine = [
+  RubyOnAcid::SineFactory.new(0.1),
+  RubyOnAcid::SineFactory.new(-0.2)
+]
+make_lines RubyOnAcid::CombinationFactory.new(:source_factories => factories_to_combine)

data/examples/midi.rb

@@ -3,7 +3,6 @@ require 'rubyonacid/factories/meta'
 require 'rubyonacid/factories/constant'
 require 'rubyonacid/factories/flash'
 require 'rubyonacid/factories/loop'
-require 'rubyonacid/factories/modulo'
 require 'rubyonacid/factories/random'
 require 'rubyonacid/factories/repeat'
 require 'rubyonacid/factories/sine'
@@ -35,7 +34,6 @@ factory.factory_pool << RubyOnAcid::RepeatFactory.new(
   RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1)),
   random_factory.within(:interval, 2, 100)
 )
-factory.factory_pool << RubyOnAcid::ModuloFactory.new(RubyOnAcid::LoopFactory.new(0.00001))
 
 #A skip factory, in charge of randomly resetting the meta factory.
 @resetter = RubyOnAcid::SkipFactory.new(0.999)

data/examples/quality_render.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), 'wxruby.rb')
+
+
+
+class MyApp
+
+  WIDTH = 1920
+  HEIGHT = 1080
+
+  def on_init
+    
+    ARGV.each do |file_name|
+      
+      puts "Processing #{file_name}"
+      
+      @f = YAML.load_file(file_name)
+    
+      frame = Wx::Frame.new(nil, :size => [WIDTH, HEIGHT])
+
+ 
+      #Displays drawing.
+      bitmap = Wx::Bitmap.new(WIDTH, HEIGHT)
+      bitmap.draw do |surface|
+        surface.brush = Wx::BLACK_BRUSH
+        surface.draw_rectangle(0, 0, WIDTH, HEIGHT)
+      end
+      10000.times do
+        bitmap.draw {|surface| render(surface)}
+      end
+      bitmap.draw do |surface|
+        surface.text_foreground = Wx::Colour.new(255, 255, 255, 255)
+        surface.draw_text("©2009 Jay McGavren. Licensed under a Creative Commons Attribution-Share Alike 3.0 United States License: http://creativecommons.org/licenses/by-sa/3.0/us/", 10, HEIGHT - 20)
+      end
+      
+      bitmap.save_file(file_name + ".png", Wx::BITMAP_TYPE_PNG)
+      
+    end
+    
+    exit
+ 
+  end
+
+end
+
+app = MyApp.new
+app.main_loop

data/examples/random_yaml.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), 'wxruby.rb')
+
+
+class MyApp
+
+  WIDTH = 320
+  HEIGHT = 320
+
+  def on_init
+    
+    (1..1000).each do |file_number|
+      
+      file_name = sprintf("%05d_random.jpg", file_number)
+      
+      @f = create_factory
+    
+      frame = Wx::Frame.new(nil, :size => [WIDTH, HEIGHT])
+ 
+      bitmap = Wx::Bitmap.new(WIDTH, HEIGHT)
+      bitmap.draw do |surface|
+        surface.brush = Wx::BLACK_BRUSH
+        surface.draw_rectangle(0, 0, WIDTH, HEIGHT)
+      end
+      10000.times do
+        bitmap.draw {|surface| render(surface)}
+      end
+      bitmap.draw do |surface|
+        surface.text_foreground = Wx::Colour.new(255, 255, 255, 255)
+        y = 0
+        @f.to_yaml.split("\n").each do |line|
+          surface.draw_text(line, 0, y)
+          y += 10
+        end
+      end
+      
+      File.open(file_name + ".yml", "w") do |file|
+        YAML.dump(@f, file)
+      end
+      
+      bitmap.save_file(file_name, Wx::BITMAP_TYPE_JPEG)
+      
+    end
+    
+    exit
+ 
+  end
+
+end
+
+app = MyApp.new
+app.main_loop

data/examples/raw_audio.rb

@@ -3,7 +3,6 @@ require 'rubyonacid/factories/meta'
 require 'rubyonacid/factories/constant'
 require 'rubyonacid/factories/flash'
 require 'rubyonacid/factories/loop'
-require 'rubyonacid/factories/modulo'
 require 'rubyonacid/factories/random'
 require 'rubyonacid/factories/repeat'
 require 'rubyonacid/factories/sine'
@@ -31,7 +30,6 @@ def generate_factories
     RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1)),
     random_factory.within(:interval, 2, 100)
   )
-  factory_pool << RubyOnAcid::ModuloFactory.new(RubyOnAcid::LoopFactory.new(0.00001))
   factory_pool
 end
 

data/examples/rinda_agent.rb

@@ -3,9 +3,9 @@ require 'wx'
 require 'rubyonacid/factories/meta'
 require 'rubyonacid/factories/constant'
 require 'rubyonacid/factories/flash'
-require 'rubyonacid/factories/increment'
 require 'rubyonacid/factories/loop'
 require 'rubyonacid/factories/random'
+require 'rubyonacid/factories/repeat'
 require 'rubyonacid/factories/rinda'
 require 'rubyonacid/factories/sine'
 require 'rubyonacid/factories/skip'
@@ -19,23 +19,9 @@ class MyApp < Wx::App
 
   def on_init
     
-    #The MetaFactory assigns factories to requested value types.
-    @f = RubyOnAcid::MetaFactory.new
-    #Loop factories loop from 0.0 to 1.0 (or 1.0 to 0.0 if the increment value is negative).
-    @f.factory_pool << RubyOnAcid::LoopFactory.new(0.01)
-    @f.factory_pool << RubyOnAcid::LoopFactory.new(-0.01)
-    #Random factories generate random values.
-    # @f.factory_pool << RubyOnAcid::RandomFactory.new
-    #Constant factories always return the same value,
-    @f.factory_pool << RubyOnAcid::ConstantFactory.new(rand)
-    #Sine factories produce a "wave" pattern.
-    @f.factory_pool << RubyOnAcid::SineFactory.new(0.1)
-    @f.factory_pool << RubyOnAcid::SineFactory.new(-0.1)
-    
-    rinda_factory = RubyOnAcid::RindaFactory.new(ARGV[0])
-    rinda_factory.start_service
-    @f.assign_factory(:x, rinda_factory)
-    @f.assign_factory(:y, rinda_factory)
+    @f = RubyOnAcid::RindaFactory.new(ARGV[0])
+    @f.default_factory = create_factory
+    @f.start_service
     
     #A skip factory, in charge of randomly resetting the meta factory.
     @resetter = RubyOnAcid::SkipFactory.new(0.999)
@@ -49,32 +35,109 @@ class MyApp < Wx::App
  
     #Animate periodically.
     t = Wx::Timer.new(self, 55)
-    evt_timer(55) {animate(window)}
+    evt_timer(55) do
+      window.paint{|surface| render(surface)}
+      @f.default_factory.reset_assignments if @resetter.boolean(:reset)
+    end
     t.start(33)
  
   end
  
-  def animate(window)
-     window.paint do |surface|
-       surface.pen = Wx::Pen.new(
-           Wx::Colour.new(
-             @f.within(:red, 0, 255).to_i,
-             @f.within(:green, 0, 255).to_i,
-             @f.within(:blue, 0, 255).to_i,
-             @f.within(:alpha, 50, 255).to_i
-           ),
-           @f.within(:width, 1, 5).to_i
-       )
-       surface.draw_line(
-          @f.within(:x, 0, WIDTH).to_i,
-          @f.within(:y, 0, HEIGHT).to_i,
-          @f.within(:x2, 0, WIDTH).to_i,
-          @f.within(:y2, 0, HEIGHT).to_i
-       )
-     end
-     # @f.reset_assignments if @resetter.boolean(:reset)
+  def create_factory
+    random_factory = RubyOnAcid::RandomFactory.new
+    
+    #The MetaFactory assigns factories to requested value types.
+    meta_factory = RubyOnAcid::MetaFactory.new
+    #Loop factories loop from 0.0 to 1.0 (or 1.0 to 0.0 if the increment value is negative).
+    meta_factory.factory_pool << RubyOnAcid::LoopFactory.new(0.01)
+    meta_factory.factory_pool << RubyOnAcid::LoopFactory.new(-0.01)
+    meta_factory.factory_pool << RubyOnAcid::LoopFactory.new(0.001)
+    meta_factory.factory_pool << RubyOnAcid::LoopFactory.new(-0.001)
+    #Constant factories always return the same value,
+    meta_factory.factory_pool << RubyOnAcid::ConstantFactory.new(rand)
+    meta_factory.factory_pool << RubyOnAcid::ConstantFactory.new(rand)
+    meta_factory.factory_pool << RubyOnAcid::FlashFactory.new(rand(100))
+    #Sine factories produce a "wave" pattern.
+    meta_factory.factory_pool << RubyOnAcid::SineFactory.new(0.1)
+    meta_factory.factory_pool << RubyOnAcid::SineFactory.new(-0.1)
+    meta_factory.factory_pool << RubyOnAcid::SineFactory.new(0.01)
+    meta_factory.factory_pool << RubyOnAcid::SineFactory.new(-0.01)
+    meta_factory.factory_pool << RubyOnAcid::RepeatFactory.new(
+      RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+      random_factory.within(:interval, 2, 100)
+    )
+    meta_factory.factory_pool << RubyOnAcid::RepeatFactory.new(
+      RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+      random_factory.within(:interval, 2, 100)
+    )
+    
+    meta_factory
   end
 
+  def render(surface)
+    color = Wx::Colour.new(
+      @f.get(:red, :max => 255).to_i,
+      @f.get(:green, :max => 255).to_i,
+      @f.get(:blue, :max => 255).to_i,
+      @f.get(:alpha, :min => 50, :max => 200).to_i
+    )
+    surface.pen = Wx::Pen.new(color, @f.within(:width, 1, 5).to_i)
+    surface.brush = Wx::Brush.new(color, Wx::SOLID)
+    case @f.choose(:shape,
+      :arc,
+      :polygon,
+      :line,
+      # :rectangle,
+      :circle,
+      :spline
+    )
+    when :line
+      surface.draw_line(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:x1, :max => WIDTH).to_i,
+        @f.get(:y1, :max => HEIGHT).to_i
+      )
+    when :rectangle
+      surface.draw_rectangle(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:x1, :max => WIDTH).to_i,
+        @f.get(:y1, :max => HEIGHT).to_i
+      )
+    when :circle
+      surface.draw_circle(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:width, :max => WIDTH).to_i
+      )
+    when :arc
+      surface.draw_elliptic_arc(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:width, :max => WIDTH).to_i,
+        @f.get(:height, :max => HEIGHT).to_i,
+        @f.get(:arc_start, :max => 360).to_i,
+        @f.get(:arc_end, :max => 360).to_i
+      )
+    when :polygon
+      surface.draw_polygon(make_point_array)
+    when :spline
+      surface.draw_spline(make_point_array)
+    end
+  end
+
+  def make_point_array
+    points = []
+    @f.get(:points, :min => 3, :max => 6).to_i.times do |i|
+      points << Wx::Point.new(
+        @f.get("x#{i}".to_sym, :max => WIDTH).to_i,
+        @f.get("y#{i}".to_sym, :max => HEIGHT).to_i
+      )
+    end
+    points
+  end
+  
 end
 
 app = MyApp.new

data/examples/wxruby.rb

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'wx'
+require 'rubyonacid/factories/meta'
+require 'rubyonacid/factories/combination'
+require 'rubyonacid/factories/constant'
+require 'rubyonacid/factories/flash'
+require 'rubyonacid/factories/loop'
+require 'rubyonacid/factories/random'
+require 'rubyonacid/factories/repeat'
+require 'rubyonacid/factories/sine'
+require 'rubyonacid/factories/skip'
+
+
+
+class MyApp < Wx::App
+
+  WIDTH = 480
+  HEIGHT = 480
+
+  def on_init
+    
+    @f = create_factory
+        
+    #A skip factory, in charge of randomly resetting the meta factory.
+    @resetter = RubyOnAcid::SkipFactory.new(0.999)
+    
+    #Containing frame.
+    frame = Wx::Frame.new(nil, :size => [WIDTH, HEIGHT])
+    frame.show
+ 
+    #Displays drawing.
+    window = Wx::Window.new(frame, :size => [WIDTH, HEIGHT])
+ 
+    #Animate periodically.
+    t = Wx::Timer.new(self, 55)
+    evt_timer(55) do
+      window.paint{|surface| render(surface)}
+      @f.reset_assignments if @resetter.boolean(:reset)
+    end
+    t.start(33)
+ 
+  end
+  
+  
+  def create_factory
+    
+    random_factory = RubyOnAcid::RandomFactory.new
+    
+    source_factories = []
+    #Loop factories loop from 0.0 to 1.0 (or 1.0 to 0.0 if the increment value is negative).
+    source_factories << RubyOnAcid::LoopFactory.new(0.01)
+    source_factories << RubyOnAcid::LoopFactory.new(-0.01)
+    source_factories << RubyOnAcid::LoopFactory.new(0.001)
+    source_factories << RubyOnAcid::LoopFactory.new(-0.001)
+    #Constant factories always return the same value,
+    source_factories << RubyOnAcid::ConstantFactory.new(rand)
+    source_factories << RubyOnAcid::ConstantFactory.new(rand)
+    source_factories << RubyOnAcid::FlashFactory.new(rand(100))
+    #Sine factories produce a "wave" pattern.
+    source_factories << RubyOnAcid::SineFactory.new(0.1)
+    source_factories << RubyOnAcid::SineFactory.new(-0.1)
+    source_factories << RubyOnAcid::SineFactory.new(0.01)
+    source_factories << RubyOnAcid::SineFactory.new(-0.01)
+    #A RepeatFactory wraps another factory, queries it, and repeats the same value a certain number of times.
+    source_factories << RubyOnAcid::RepeatFactory.new(
+      RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+      random_factory.get(:interval, :min => 2, :max => 100)
+    )
+    source_factories << RubyOnAcid::RepeatFactory.new(
+      RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+      random_factory.get(:interval, :min => 2, :max => 100)
+    )
+    #A CombinationFactory combines the values of two or more other factories.
+    combination_factory = RubyOnAcid::CombinationFactory.new
+    2.times do
+      combination_factory.source_factories << source_factories[rand(source_factories.length)]
+    end
+    source_factories << combination_factory
+    
+    #The MetaFactory pulls requested value types from the other factories.
+    meta_factory = RubyOnAcid::MetaFactory.new
+    meta_factory.factory_pool = source_factories
+    
+    meta_factory
+    
+  end
+ 
+ 
+  def render(surface)
+    color = Wx::Colour.new(
+      @f.get(:red, :max => 255).to_i,
+      @f.get(:green, :max => 255).to_i,
+      @f.get(:blue, :max => 255).to_i,
+      @f.get(:alpha, :min => 50, :max => 200).to_i
+    )
+    surface.pen = Wx::Pen.new(color, @f.within(:width, 1, 5).to_i)
+    surface.brush = Wx::Brush.new(color, Wx::SOLID)
+    case @f.choose(:shape,
+      :arc,
+      :polygon,
+      :line,
+      :rectangle,
+      :circle,
+      :spline
+    )
+    when :line
+      surface.draw_line(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:x1, :max => WIDTH).to_i,
+        @f.get(:y1, :max => HEIGHT).to_i
+      )
+    when :rectangle
+      surface.draw_rectangle(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:x1, :max => WIDTH).to_i,
+        @f.get(:y1, :max => HEIGHT).to_i
+      )
+    when :circle
+      surface.draw_circle(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:width, :max => 100).to_i
+      )
+    when :arc
+      surface.draw_elliptic_arc(
+        @f.get(:x0, :max => WIDTH).to_i,
+        @f.get(:y0, :max => HEIGHT).to_i,
+        @f.get(:width, :max => 100).to_i,
+        @f.get(:height, :max => 100).to_i,
+        @f.get(:arc_start, :max => 360).to_i,
+        @f.get(:arc_end, :max => 360).to_i
+      )
+    when :polygon
+      surface.draw_polygon(make_point_array)
+    when :spline
+      surface.draw_spline(make_point_array)
+    end
+  end
+  
+  
+  def make_point_array
+    points = []
+    3.times do |i|
+      points << Wx::Point.new(
+        @f.get("x#{i}".to_sym, :max => WIDTH).to_i,
+        @f.get("y#{i}".to_sym, :max => HEIGHT).to_i
+      )
+    end
+    points
+  end
+
+
+end
+
+app = MyApp.new
+app.main_loop

data/lib/rubyonacid/factories/combination.rb

@@ -0,0 +1,66 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class CombinationFactory < Factory
+  
+  ADD = :add
+  SUBTRACT = :subtract
+  MULTIPLY = :multiply
+  DIVIDE = :divide
+  CONSTRAIN = :constrain
+  WRAP = :wrap
+  
+  attr_accessor :source_factories
+  attr_accessor :operation
+  attr_accessor :constrain_mode
+  
+  def initialize(options = {})
+    super
+    @source_factories = options[:source_factories] || []
+    @operation = options[:operation] || ADD
+    @constrain_mode = options[:constrain_mode] || WRAP
+  end
+  
+  def get_unit(key)
+    combined_value = combine(key)
+    constrain(combined_value)
+  end
+  
+  private
+    
+    def combine(key)
+      initial_value = @source_factories.first.get_unit(key)
+      additional_values = @source_factories.slice(1, @source_factories.length - 1).map {|f| f.get_unit(key)}
+      case @operation
+      when ADD
+        return additional_values.inject(initial_value) {|sum, value| sum + value}
+      when SUBTRACT
+        return additional_values.inject(initial_value) {|sum, value| sum - value}
+      when MULTIPLY
+        return additional_values.inject(initial_value) {|product, value| product * value}
+      when DIVIDE
+        return additional_values.inject(initial_value) {|product, value| product / value}
+      else
+        raise "invalid operation - must be ADD, MULTIPLY, SUBTRACT, or DIVIDE"
+      end
+    end
+    
+    def constrain(value)
+      case @constrain_mode
+      when CONSTRAIN
+        if value > 1.0
+          return 1.0
+        elsif value < 0.0
+          return 0.0
+        else
+          return value
+        end
+      when WRAP
+        return value % 1.0
+      end
+    end
+  
+end
+
+end

data/lib/rubyonacid/factories/increment.rb

@@ -3,7 +3,8 @@ require 'rubyonacid/factory'
 module RubyOnAcid
 
 class IncrementFactory < Factory
-  
+
+  #The amount to increment counters by.
   attr_accessor :interval
   def interval=(value)
     @interval = value
@@ -18,7 +19,7 @@ class IncrementFactory < Factory
     @interval = interval
   end
   
-  #Increment counter for key and get its sine, then scale it between 0 and 1.
+  #Increment counter for given key and return it. Constrain between 0 and 1.
   def get_unit(key)
     @counters[key] ||= @start_value
     @counters[key] += @interval