variation 0.2.0

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+doc/
+pkg/
+vendor/cache/*.gem
+.yardoc
+*~
+.project

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title "variation Documentation" --protected

data/ChangeLog.rdoc

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2013-08-26
+
+* Initial release:
+  Three types of changes: immediate, linear, and sigmoid.

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 James Tunnell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,53 @@
+= variation
+
+* {Homepage}[https://rubygems.org/gems/variation]
+* {Documentation}[http://rubydoc.info/gems/variation/frames]
+* {Email}[mailto:jamestunnell at gmail.com]
+
+== Description
+
+Compute values that change with time (or some independent variable), using various transitions (immediate, linear, sigmoid) between values.
+
+== Features
+
+A variety of transitions:
+ * immediate
+ * linear
+ * sigmoid (s-shaped)
+
+== Examples
+
+  require 'variation'
+  include Variation
+
+  p = Profile.new(
+    :start_value => 1,
+    :changes => {
+      3 => ImmediateChange.new(:end_value => 3),
+      5 => SigmoidChange.new(:end_value => 4, :length => 2),
+      6 => LinearChange.new(:end_value => 1, :length => 1)
+    }
+  )
+
+  # generate a function to calculate profile values
+  f = p.function
+  f.call(0) # should return 1
+  f.call(3 - 1e-5) # should return 1
+  f.call(3) # should return 3
+  f.call(4) # should return 3.5
+  f.call(5) # should return 4
+  f.call(5.5) # should return 2.5
+  f.call(6) # should return 1
+  f.call(99) # should return 1
+
+== Requirements
+
+== Install
+
+  $ gem install variation
+
+== Copyright
+
+Copyright (c) 2013 James Tunnell
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rspec', '~> 2.4'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test    => :spec
+task :default => :spec
+
+require "bundler/gem_tasks"
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(Gem::Specification.load('variation.gemspec')) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = false
+end

data/lib/variation.rb

@@ -0,0 +1,12 @@
+require 'variation/version'
+
+require 'variation/errors'
+require 'variation/range'
+require 'variation/functions/constant_function'
+require 'variation/functions/linear_function'
+require 'variation/functions/sigmoid_function'
+require 'variation/change'
+require 'variation/changes/immediate_change'
+require 'variation/changes/linear_change'
+require 'variation/changes/sigmoid_change'
+require 'variation/profile'

data/lib/variation/change.rb

@@ -0,0 +1,23 @@
+module Variation
+class Change
+  attr_reader :length, :end_value
+
+  # Pass :length and :end_value by hash. Length must be > 0.
+  def initialize hashed_args
+    raise HashedArgMissingError unless hashed_args.has_key?(:length)
+    raise HashedArgMissingError unless hashed_args.has_key?(:end_value)
+
+    self.length = hashed_args[:length]
+    self.end_value = hashed_args[:end_value]
+  end
+
+  def length= length
+    raise NegativeLengthError if length < 0
+    @length = length
+  end
+
+  def end_value= end_value
+    @end_value = end_value
+  end
+end
+end

data/lib/variation/changes/immediate_change.rb

@@ -0,0 +1,12 @@
+module Variation
+class ImmediateChange < Change
+  # Pass :end_value by hash.
+  def initialize hashed_args
+    super(hashed_args.merge(:length => 0))
+  end
+
+  def transition_function start_point
+    ConstantFunction.from_value end_value
+  end
+end
+end

data/lib/variation/changes/linear_change.rb

@@ -0,0 +1,13 @@
+module Variation
+class LinearChange < Change
+  # Pass :length and :end_value by hash. Length must be > 0.
+  def initialize hashed_args
+    super(hashed_args)
+  end
+
+  def transition_function start_point
+    end_point = [start_point[0] + length, end_value]
+    LinearFunction.from_points start_point, end_point
+  end
+end
+end

data/lib/variation/changes/sigmoid_change.rb

@@ -0,0 +1,14 @@
+module Variation
+class SigmoidChange < Change
+  # Pass :length and :end_value by hash. Length must be > 0.
+  def initialize hashed_args
+    super(hashed_args)
+    @abruptness = hashed_args[:abruptness] || 0.5
+  end
+
+  def transition_function start_point
+    end_point = [start_point[0] + length, end_value]
+    SigmoidFunction.from_points start_point, end_point, @abruptness
+  end
+end
+end

data/lib/variation/errors.rb

@@ -0,0 +1,7 @@
+module Variation
+  class NegativeLengthError < StandardError; end
+  class OutsideOfDomainError < StandardError; end
+  class NotBetweenZeroAndOneError < StandardError; end
+  class RangeNotIncreasingError < StandardError; end
+  class HashedArgMissingError < StandardError; end
+end

data/lib/variation/functions/constant_function.rb

@@ -0,0 +1,7 @@
+module Variation
+class ConstantFunction
+  def self.from_value value
+    ->(x){ value }
+  end
+end
+end

data/lib/variation/functions/linear_function.rb

@@ -0,0 +1,12 @@
+module Variation
+class LinearFunction
+  def self.from_points pt_a, pt_b, abruptness = 0.5
+    slope = (pt_b[1] - pt_a[1]) / (pt_b[0] - pt_a[0]).to_f
+    intercept = pt_a[1] - (slope * pt_a[0])
+
+    lambda do |x|
+      (slope * x) + intercept
+    end
+  end
+end
+end

data/lib/variation/functions/sigmoid_function.rb

@@ -0,0 +1,28 @@
+module Variation
+class SigmoidFunction
+  def self.from_points pt_a, pt_b, abruptness = 0.5
+    raise NotBetweenZeroAndOneError unless abruptness.between?(0,1)
+
+    domain = pt_a[0]..pt_b[0]
+    codomain = pt_a[1]..pt_b[1]
+
+    magn = LinearFunction.from_points([0,3],[1,9]).call(abruptness)
+    tanh_domain = -magn..magn
+    tanh_codomain = Math::tanh(-magn)..Math::tanh(magn)
+
+    domain_transformer = LinearFunction.from_points(
+      [domain.first, tanh_domain.first],
+      [domain.last, tanh_domain.last]
+    )
+
+    codomain_transformer = LinearFunction.from_points(
+      [tanh_codomain.first, codomain.first],
+      [tanh_codomain.last, codomain.last]
+    )
+
+    lambda do |x|
+      codomain_transformer.call(Math::tanh(domain_transformer.call(x)))
+    end
+  end
+end
+end

data/lib/variation/profile.rb

@@ -0,0 +1,130 @@
+module Variation
+
+# Represent a setting that can change over time.
+class Profile
+
+  attr_reader :start_value, :changes
+
+  def initialize hashed_args
+    raise HashedArgMissingError unless hashed_args.has_key?(:start_value)
+    changes = hashed_args[:changes] || {}
+
+    @start_value = hashed_args[:start_value]
+    @changes = changes
+    
+    trim_changes_if_needed @changes
+  end
+
+  def length
+    length = 0
+    if @changes.any?
+      first_offset = @changes.keys.min
+      last_offset = @changes.keys.max
+      length = (last_offset - first_offset) + @changes[first_offset].length
+    end
+    return length
+  end
+
+  # def select range
+  #   raise OutsideOfDomainError unless domain.include?(x_range.first)
+  #   raise OutsideOfDomainError unless domain.include?(x_range.last)    
+    
+  #   changes = {}
+  #   @changes.each do |offset, change|
+  #     change_end = offset + change.length
+  #     if range.include?(offset) && range.include?(change_end)
+  #       changes[offset] = change
+  #     elsif range.include?(offset)
+  #       changes[offset] = change.truncate_end(range.last - offset)
+  #     elsif range.include?(change_end)
+  #       changes[range.first] = change.truncate_start(change_end - range.first)
+  #     end
+  #   end
+
+  #     changes = @changes.select do |offset, change|
+  #       range.include?(offset) || range.include?(offset + change.length)
+  #     end
+      
+  #     if changes.keys.min < range.first
+
+  #     if first_offset 
+  #     last_offset = changes.keys.max
+
+  #   end
+  #   Profile.new(@start_value, changes)
+  # end
+
+  def end_value
+    if @changes.any?
+      @changes[@changes.keys.max].end_value
+    else
+      start_value
+    end
+  end
+
+  def function
+    functions = {}
+
+    prev_val = start_value
+    prev_offset = -Float::INFINITY
+
+    if @changes.any?
+      sorted_offsets = @changes.keys.sort
+
+      sorted_offsets.each_index do |i|
+        offset = sorted_offsets[i]
+        change = @changes[offset]
+        start_of_transition = offset - change.length
+
+        unless prev_offset == start_of_transition
+          functions[prev_offset...start_of_transition] = ConstantFunction.from_value(prev_val)
+        end
+        functions[start_of_transition...offset] = change.transition_function([start_of_transition, prev_val])
+
+        prev_val = change.end_value
+        prev_offset = offset
+      end
+    end
+
+    functions[prev_offset...Float::INFINITY] = ConstantFunction.from_value(prev_val)
+
+    lambda do |x|
+      result = functions.find {|domain,func| domain.include?(x) }
+      f = result[1]
+      f.call(x)
+    end
+  end
+
+  def at(x)
+    function.call(x)
+  end
+
+  def data(step_size)
+    data = {}
+    if @changes.any?
+      f = function
+      domain = (@changes.keys.max - length)..length
+      domain.step(step_size) do |x|
+        data[x] = f.call(x)
+      end
+    end
+    return data
+  end
+
+  private
+
+  def trim_changes_if_needed changes
+    offsets = changes.keys.sort
+    for i in 1...offsets.count
+      prev_offset = offsets[i-1]
+      offset = offsets[i]
+      change = changes[offset]
+      
+      if (offset - change.length) < prev_offset
+        change.length = offset - prev_offset
+      end
+    end
+  end
+end
+
+end

data/lib/variation/range.rb

@@ -0,0 +1,66 @@
+class Range
+  class RangeDecreasingError < StandardError; end
+
+  def decreasing?
+    if exclude_end?
+      last < first
+    else
+      last <= first
+    end
+  end
+
+  def intersect? other
+    raise RangeDecreasingError if other.decreasing?
+
+    if other.first > last
+      return false
+    elsif other.first == last && exclude_end?
+      return false
+    elsif other.last < first
+      return false
+    elsif other.last == first && other.exclude_end?
+      return false
+    else
+      return true
+    end
+  end
+
+  def intersection(other)
+    raise RangeDecreasingError if other.decreasing?
+
+    if intersect?(other)
+      if include? other.first
+        start = other.first
+      else  # other.first < first
+        start = first
+      end
+
+      if exclude_end?
+        if other.exclude_end?
+          return start...(last < other.last ? last : other.last)
+        else # other is inclusive
+          if other.last <= last
+            return start..other.last
+          else
+            return start...last
+          end
+        end
+      else # self is inclusize
+        if other.exclude_end?
+          if other.last >= last
+            return start..last
+          else other.last < last
+            return start...other.last
+          end
+        else # other is inclusive as well
+          return start..(last < other.last ? last : other.last)
+        end
+      end
+    end
+    
+    return nil
+  end
+
+  alias_method :&, :intersection
+  alias_method :intersect, :intersection
+end

data/lib/variation/version.rb

@@ -0,0 +1,4 @@
+module Variation
+  # variation version
+  VERSION = "0.2.0"
+end

data/spec/changes/immediate_change_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ImmediateChange do
+  describe '.new' do
+    context 'empty hash given' do
+      it 'should raise HashedArgMissingError' do
+        expect { ImmediateChange.new({}) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':end_value given' do
+      it 'should raise HashedArgMissingError' do
+        expect { ImmediateChange.new(:end_value => 1) }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#transition_function' do
+    it 'should return a Proc with arity of 1' do
+      [ 2, 5.5 ].each do |value|
+        ImmediateChange.new(:end_value => value).transition_function([0,0]).arity.should eq(1)
+      end
+    end
+
+    it 'should return a Proc, that returns the given constant value regardless of the argument' do
+      [ 2, 5.5 ].each do |value|
+        f = ImmediateChange.new(:end_value => value).transition_function([0,0])
+        f.call(1).should eq(value)
+        f.call(1000).should eq(value)
+      end
+    end
+  end
+end

data/spec/changes/linear_change_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe LinearChange do
+  describe '.new' do
+    context 'empty hash given' do
+      it 'should raise HashedArgMissingError' do
+        expect { LinearChange.new({}) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':length only given' do
+      it 'should raise HashedArgMissingError' do
+        expect { LinearChange.new(:length => 2) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':end_value only given' do
+      it 'should raise HashedArgMissingError' do
+        expect { LinearChange.new(:end_value => 1) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':length and :end_value given' do
+      it 'should raise HashedArgMissingError' do
+        expect { LinearChange.new(:end_value => 1, :length => 2) }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#transition_function' do
+    it 'should return a Proc with arity of 1' do
+      LinearChange.new(:end_value => 1, :length => 1).transition_function([0,0]).arity.should eq(1)
+      LinearChange.new(:end_value => 3, :length => 2).transition_function([1,2]).arity.should eq(1)
+    end
+
+    context 'end value 1.2 and length 2' do
+      before :all do
+        @change = LinearChange.new(:end_value => 1.2, :length => 2)
+      end
+
+      context 'given start point [0,1.1]' do
+        it 'should produce a function that follows the equation y = 0.05x + 1.1' do
+          f = @change.transition_function([0,1.1])
+          f.call(0).should eq(1.1)
+          f.call(0.5).should eq(1.125)
+          f.call(1).should eq(1.15)
+          f.call(1.5).should eq(1.175)
+          f.call(2).should eq(1.2)
+        end
+      end
+    end
+  end
+end

data/spec/changes/sigmoid_change_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SigmoidChange do
+  describe '.new' do  
+    context 'empty hash given' do
+      it 'should raise HashedArgMissingError' do
+        expect { SigmoidChange.new({}) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':length only given' do
+      it 'should raise HashedArgMissingError' do
+        expect { SigmoidChange.new(:length => 2) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':end_value only given' do
+      it 'should raise HashedArgMissingError' do
+        expect { SigmoidChange.new(:end_value => 1) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context ':length and :end_value given' do
+      it 'should raise HashedArgMissingError' do
+        expect { SigmoidChange.new(:end_value => 1, :length => 2) }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#transition_function' do
+    it 'should return a Proc with arity of 1' do
+      SigmoidChange.new(:end_value => 1, :length => 1).transition_function([0,0]).arity.should eq(1)
+      SigmoidChange.new(:end_value => 3, :length => 2).transition_function([1,2]).arity.should eq(1)
+    end
+
+    context 'end value 1.2 and length 2' do
+      before :all do
+        @change = SigmoidChange.new(:end_value => 1.25, :length => 2)
+      end
+
+      context 'given start point [0,1.1]' do
+        it 'should produce a function that...' do
+          f = @change.transition_function([0,1.0])
+          f.call(0).should eq(1.0)
+          f.call(1).should eq(1.125)
+          f.call(2).should eq(1.25)
+        end
+      end
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe NegativeLengthError do
+end
+
+describe OutsideOfDomainError do
+end
+
+describe NotBetweenZeroAndOneError do
+end
+
+describe RangeNotIncreasingError do
+end

data/spec/functions/constant_function_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ConstantFunction do
+  describe '.from_value' do
+    it 'should return a Proc with arity of 1' do
+      ConstantFunction.from_value(0).arity.should eq(1)
+      ConstantFunction.from_value(125).arity.should eq(1)
+    end
+
+    it 'should return a Proc, that returns the given constant value regardless of the argument' do
+      f = ConstantFunction.from_value(0)
+      f.call(1).should eq(0)
+      f.call(1000).should eq(0)
+
+      f = ConstantFunction.from_value(-1)
+      f.call(1).should eq(-1)
+      f.call(1000).should eq(-1)
+    end
+  end
+end

data/spec/functions/linear_function_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe LinearFunction do
+  describe '.from_points' do
+    it 'should return a Proc with arity of 1' do
+      LinearFunction.from_points([0,0],[1,1]).arity.should eq(1)
+      LinearFunction.from_points([1,2],[2,3]).arity.should eq(1)
+    end
+
+    context 'given points [0,1.1] and [2,1.2]' do
+      it 'should produce a function that follows the equation y = 0.05x + 1.1' do
+        f = LinearFunction.from_points [0,1.1], [2,1.2]
+        f.call(0).should eq(1.1)
+        f.call(0.5).should eq(1.125)
+        f.call(1).should eq(1.15)
+        f.call(1.5).should eq(1.175)
+        f.call(2).should eq(1.2)
+      end
+    end
+  end
+end

data/spec/functions/sigmoid_function_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SigmoidFunction do
+  describe '.from_points' do
+    context 'given abruptness less than zero' do
+      it 'should raise NotBetweenZeroAndOneError' do
+        expect { SigmoidFunction.from_points([0,0],[1,1],-0.01) }.to raise_error(NotBetweenZeroAndOneError)
+      end
+    end
+
+    context 'given abruptness greater than 1' do
+      it 'should raise NotBetweenZeroAndOneError' do
+        expect { SigmoidFunction.from_points([0,0],[1,1],1.01) }.to raise_error(NotBetweenZeroAndOneError)
+      end
+    end
+
+    context 'given abruptness between 0 and 1' do
+      it 'should not raise any error' do
+        (0..1).step(0.1) do |abruptness|
+          expect { SigmoidFunction.from_points([0,0],[1,1],abruptness) }.to_not raise_error
+        end
+      end
+    end
+
+    it 'should return a Proc with arity of 1' do
+      SigmoidFunction.from_points([0,0],[1,1]).arity.should eq(1)
+      SigmoidFunction.from_points([1,2],[2,3]).arity.should eq(1)
+    end
+
+    context 'given points [0,1.1] and [2,1.2]' do
+      it 'should produce a function that...' do
+        f = SigmoidFunction.from_points [0,1.0], [2,1.25]
+        f.call(0).should eq(1.0)
+        f.call(1).should eq(1.125)
+        f.call(2).should eq(1.25)
+      end
+    end
+  end
+end

data/spec/profile_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+require 'spcore'
+
+describe Profile do
+  describe '.new' do
+    context 'no :start_value given' do
+      it 'should raise HashedArgMissingError' do
+        expect { Profile.new({}) }.to raise_error(HashedArgMissingError)
+      end
+    end
+
+    context 'no :changes given' do
+      it 'should not raise error' do
+        expect { Profile.new(:start_value => 2) }.to_not raise_error
+      end
+
+      it 'should default changes to empty hash' do
+        Profile.new(:start_value => 2).changes.should be_empty
+      end
+    end
+  end
+
+  describe '#length' do
+    it 'should return difference from last change offset and (first change offset + first change length)' do
+      Profile.new(
+        :start_value => 1, 
+        :changes => {
+          2 => LinearChange.new(:end_value => 2, :length => 2),
+          8 => SigmoidChange.new(:end_value => 0, :length => 3)
+        }
+      ).length.should eq(8)
+    end
+  end
+
+  describe '#function' do
+    before :all do
+      @profiles = [
+        Profile.new(
+          :start_value => 2.0,
+          :changes => {
+            1 => LinearChange.new(:end_value => 3.5, :length => 1),
+            4 => LinearChange.new(:end_value => 1.5, :length => 2)
+          }
+        ),
+        Profile.new(
+          :start_value => 1,
+          :changes => {
+            2 => LinearChange.new(:end_value => 2, :length => 2),
+            8 => SigmoidChange.new(:end_value => 0, :length => 3)
+          }
+        ),
+        Profile.new(
+          :start_value => -20,
+          :changes => {
+            -5 => ImmediateChange.new(:end_value => 3),
+            0 => ImmediateChange.new(:end_value => 3),
+            5 => SigmoidChange.new(:end_value => 2, :length => 1)
+          }
+        )
+      ]
+    end
+
+    describe '#function#arity' do
+      it 'should be 1' do
+        @profiles.each do |profile|
+          profile.function.arity.should eq(1)
+        end
+      end
+    end
+
+    describe '#function#call' do
+      context 'given first change offset' do
+        it 'should return first change value' do
+          @profiles.each do |profile|
+            first_offset = profile.changes.keys.min
+            first_change = profile.changes[first_offset]
+            profile.function.call(first_offset).should eq(first_change.end_value)
+          end
+        end
+      end
+
+      context 'changes with length == 0 (i.e. immediate changes)' do
+        before :all do
+          @profile = Profile.new(
+            :start_value => -20,
+            :changes => {
+              -5 => ImmediateChange.new(:end_value => 3),
+              0 => ImmediateChange.new(:end_value => 5),
+              5 => ImmediateChange.new(:end_value => 2)
+            }
+          )
+          @function = @profile.function
+        end
+
+        context 'given change offset' do
+          it 'should return change end value' do
+            @profile.changes.each do |offset, change|
+              @function.call(offset).should eq(change.end_value)
+            end
+          end
+        end
+
+        context 'given just before change offset' do
+          it 'should return change end value' do
+            @profile.changes.each do |offset, change|
+              @function.call(offset - 1e-5).should_not eq(change.end_value)
+            end
+          end
+        end
+      end
+
+      context 'changes with length > 0' do
+        before :all do
+          @profile = Profile.new(
+            :start_value => -20,
+            :changes => {
+              -5 => LinearChange.new(:end_value => 3, :length => 2),
+              0 => LinearChange.new(:end_value => 1, :length => 1),
+              5 => SigmoidChange.new(:end_value => -10, :length => 2.5),
+            }
+          )
+          @function = @profile.function
+        end
+
+        context 'given change offset' do
+          it 'should return change end value' do
+            @profile.changes.each do |offset, change|
+              @function.call(offset).should eq(change.end_value)
+            end
+          end
+        end
+
+        context 'given (change offset - change length)' do
+          context 'first change' do
+            it 'should return the start value' do
+              first_offset = @profile.changes.keys.min
+              first_change = @profile.changes[first_offset]
+              @function.call(first_offset - first_change.length).should eq(@profile.start_value)
+            end
+          end
+
+          context 'second and later changes' do
+            it 'should return end value of previous change' do
+              sorted_offsets = @profile.changes.keys.sort
+              for i in 1...sorted_offsets.count
+                offset = sorted_offsets[i]
+                change = @profile.changes[offset]
+                prev_change = @profile.changes[sorted_offsets[i-1]]
+
+                @function.call(offset - change.length).should eq(prev_change.end_value)
+              end
+            end
+          end
+        end
+
+        context 'given (change offset - 1/2 change length)' do
+          context 'first change' do
+            it 'should return 1/2 between start value and change end value' do
+              first_offset = @profile.changes.keys.min
+              first_change = @profile.changes[first_offset]
+              
+              halfway = first_offset - (first_change.length / 2.0)
+              expected = @profile.start_value + (first_change.end_value - @profile.start_value) / 2.0
+              @function.call(halfway).should eq(expected)
+            end
+          end
+
+          context 'second and later changes' do
+            it 'should return 1/2 between end value of previous change and end value of current change' do
+              sorted_offsets = @profile.changes.keys.sort
+              for i in 1...sorted_offsets.count
+                offset = sorted_offsets[i]
+                change = @profile.changes[offset]
+                prev_change = @profile.changes[sorted_offsets[i-1]]
+
+                halfway = offset - (change.length / 2.0)
+                expected = prev_change.end_value + (change.end_value - prev_change.end_value) / 2.0
+                @function.call(halfway).should eq(expected)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/range_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'Range#intersection' do
+  it 'should raise error if the other given range is decreasing' do
+    expect { (0..2).intersection(1..0) }.to raise_error
+  end
+
+  context 'range includes end' do
+    context 'second range ends before the first begins' do
+      it 'should return nil' do
+        (5..10).intersection(1..4).should be_nil
+      end
+    end
+
+    context 'second range starts before the first range starts' do
+      context 'second range ends where the first begins' do
+        context 'second range excludes end' do
+          it 'should return nil' do
+            (5..10).intersection(1...5).should be_nil
+          end
+        end
+
+        context 'second range includes end' do
+          it 'should return a range with the same start/end' do
+            (5..10).intersection(1..5).should eq(5..5)
+          end
+        end
+      end
+
+      context 'second range ends inside first range' do
+        it 'should return a range that starts where the first range starts and ends where the second range ends' do
+          (5..10).intersection(4..6).should eq(5..6)
+          (5..10).intersection(4...6).should eq(5...6)
+        end
+      end
+    end
+
+    context 'second range starts where the first range starts' do
+
+    end
+
+    context 'second range starts inside the first range' do
+      context 'second range ends inside the first range' do
+        it 'should return the second range' do
+          (5..10).intersection(6..9).should eq(6..9)
+          (5..10).intersection(6...8).should eq(6...8)
+        end
+      end
+
+      context 'second range ends where the first range ends' do
+        context 'second range is inclusive' do
+          it 'should return the second range' do
+            (5..10).intersection(6..10).should eq(6..10)
+          end
+        end
+
+        context 'second range is exclusize' do
+          it 'should return an inclusize version of the second range' do
+            (5..10).intersection(6...10).should eq(6..10)
+          end
+        end
+      end
+
+      context 'second range ends after the first range ends' do
+        it 'should return a range starting with the second range and ending with the first' do
+          (5..10).intersection(6..11).should eq(6..10)
+        end
+      end
+    end
+
+    context 'second range starts where the first ends' do
+      it 'should return a range with the same start/end' do
+        (5..10).intersection(10..15).should eq(10..10)
+      end
+    end
+
+
+    context 'second range starts after the first ends' do
+      it 'should return nil' do
+        (5..10).intersection(11..15).should be_nil
+      end
+    end
+  end
+
+  context 'range excludes end' do
+    before :all do
+      @range = 5...10
+    end
+
+    context 'second range starts where the first ends' do
+      it 'should return nil' do
+        @range.intersection(10..15).should be_nil
+      end
+    end
+
+    context 'second range starts inside the first range' do
+      context 'second range ends outside the first range' do
+        it 'should start where second range starts and end where first range ends (but exclude end)' do
+          @range.intersection(5..15).should eq(5...10)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+gem 'rspec', '~> 2.4'
+require 'rspec'
+require 'variation'
+require 'pry'
+
+include Variation

data/spec/variation_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'variation'
+
+describe Variation do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+end

data/variation.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/variation/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "variation"
+  gem.version       = Variation::VERSION
+  gem.summary       = %q{Compute values that change with time, with various transitions (immediate, linear, sigmoid)}
+  gem.description   = %q{Compute values that change with time (or some independent variable), using various transitions (immediate, linear, sigmoid) between values.}
+  gem.license       = "MIT"
+  gem.authors       = ["James Tunnell"]
+  gem.email         = "jamestunnell@gmail.com"
+  gem.homepage      = "https://rubygems.org/gems/variation"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'gnuplot'
+
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'pry'
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: variation
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- James Tunnell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gnuplot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Compute values that change with time (or some independent variable),
+  using various transitions (immediate, linear, sigmoid) between values.
+email: jamestunnell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .yardopts
+- ChangeLog.rdoc
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/variation.rb
+- lib/variation/change.rb
+- lib/variation/changes/immediate_change.rb
+- lib/variation/changes/linear_change.rb
+- lib/variation/changes/sigmoid_change.rb
+- lib/variation/errors.rb
+- lib/variation/functions/constant_function.rb
+- lib/variation/functions/linear_function.rb
+- lib/variation/functions/sigmoid_function.rb
+- lib/variation/profile.rb
+- lib/variation/range.rb
+- lib/variation/version.rb
+- spec/changes/immediate_change_spec.rb
+- spec/changes/linear_change_spec.rb
+- spec/changes/sigmoid_change_spec.rb
+- spec/errors_spec.rb
+- spec/functions/constant_function_spec.rb
+- spec/functions/linear_function_spec.rb
+- spec/functions/sigmoid_function_spec.rb
+- spec/profile_spec.rb
+- spec/range_spec.rb
+- spec/spec_helper.rb
+- spec/variation_spec.rb
+- variation.gemspec
+homepage: https://rubygems.org/gems/variation
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Compute values that change with time, with various transitions (immediate,
+  linear, sigmoid)
+test_files:
+- spec/changes/immediate_change_spec.rb
+- spec/changes/linear_change_spec.rb
+- spec/changes/sigmoid_change_spec.rb
+- spec/errors_spec.rb
+- spec/functions/constant_function_spec.rb
+- spec/functions/linear_function_spec.rb
+- spec/functions/sigmoid_function_spec.rb
+- spec/profile_spec.rb
+- spec/range_spec.rb
+- spec/spec_helper.rb
+- spec/variation_spec.rb
+has_rdoc: