tealeaves 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+notifications:
+  recipients:
+    - roland.swingler@gmail.com
+branches:
+  only:
+    - master
+bundler_args: --without development

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rake"
+  gem "rspec", "~> 2.8.0"
+  gem "yard", "~> 0.7"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "rcov", ">= 0"
+end
+
+group :test do
+  gem "rake"
+  gem "rspec", "~> 2.8.0"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Roland Swingler
+
+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,40 @@
+= tealeaves
+
+{<img src="https://secure.travis-ci.org/knaveofdiamonds/tealeaves.png?branch=master" alt="Build Status" />}[http://travis-ci.org/knaveofdiamonds/tealeaves]
+
+Tealeaves is a simple forecasting toolset for ruby, able to product short term forecasts for time series data.
+
+It implements Exponential Smoothing methods, including those dealing with seasonality & trends, and has some basic functionality to determine optimal models.
+
+== Usage
+
+    require 'tealeaves'
+
+    # A set of time series data
+    data = [1.0, 3.3 ... 24.56]
+
+    # Period, for example 12 for monthly data
+    period = 12
+
+    # Get an 'optimal' model
+    TeaLeaves.optimal_model(data, period)
+
+    # Or next period's forecasts from the optimal model
+    TeaLeaves.forecast(data, period)
+
+    # Or the next n period's forecasts from the optimal model
+    TeaLeaves.forecast(data, period, 3)
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Roland Swingler. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  if ENV["TRAVIS"]
+    Bundler.setup(:default, :test)
+  else
+    Bundler.setup(:default, :development)
+  end
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+    gem.name = "tealeaves"
+    gem.homepage = "http://github.com/knaveofdiamonds/tealeaves"
+    gem.license = "MIT"
+    gem.summary = %Q{Simple Forecasting Methods in Ruby}
+    gem.description = %Q{Exponential smoothing based forecasting methods for time series data}
+    gem.email = "roland.swingler@gmail.com"
+    gem.authors = ["Roland Swingler"]
+    # dependencies defined in Gemfile
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError => e
+  $stderr.puts "Not loading standard development tasks."
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/tealeaves.rb

@@ -0,0 +1,17 @@
+require 'tealeaves/moving_average'
+require 'tealeaves/seasonal_components'
+require 'tealeaves/forecast'
+require 'tealeaves/naive_forecast'
+require 'tealeaves/single_exponential_smoothing_forecast'
+require 'tealeaves/brute_force_optimization'
+require 'tealeaves/exponential_smoothing_forecast'
+
+module TeaLeaves
+  def self.optimal_model(time_series, period)
+    BruteForceOptimization.new(time_series, period).optimize
+  end
+
+  def self.forecast(time_series, period, periods_ahead=nil)
+    optimal_model(time_series, period).predict(periods_ahead)
+  end
+end

data/lib/tealeaves/brute_force_optimization.rb

@@ -0,0 +1,84 @@
+module TeaLeaves
+  class BruteForceOptimization
+    INITIAL_PARAMETER_VALUES = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0].freeze
+    
+    def initialize(time_series, period, opts={})
+      @time_series = time_series
+      @period = period
+      @opts = opts
+    end
+
+
+    def optimize
+      [0.1, 0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625].inject(optimum(initial_models)) do |model, change|
+        improve_model(model, change)
+      end
+    end
+
+    def initial_test_parameters(opts={})
+      parameters = []
+      INITIAL_PARAMETER_VALUES.each do |alpha|
+        parameters << {:alpha => alpha, :seasonality => :none, :trend => :none}
+        
+        unless opts[:seasonality] == :none && opts[:trend] == :none
+          INITIAL_PARAMETER_VALUES.each do |b|
+            parameters << {:alpha => alpha, :beta => b, :seasonality => :none, :trend => :additive}
+            parameters << {:alpha => alpha, :beta => b, :seasonality => :none, :trend => :multiplicative}
+            parameters << {:alpha => alpha, :gamma => b, :trend => :none, :seasonality => :additive}
+            parameters << {:alpha => alpha, :gamma => b, :trend => :none, :seasonality => :multiplicative}
+            
+            INITIAL_PARAMETER_VALUES.each do |gamma|
+              [:additive, :multiplicative].each do |trend|
+                [:additive, :multiplicative].each do |seasonality|
+                  parameters << {
+                    :alpha => alpha,
+                    :beta => b,
+                    :gamma => gamma,
+                    :trend => trend,
+                    :seasonality => seasonality
+                  }
+                end
+              end
+            end
+          end
+        end
+      end
+
+      parameters
+    end
+
+    private
+
+    def improve_model(model, change)
+      trend_operations = model.trend == :none ? [nil] : [:+, :-, nil]
+      season_operations = model.seasonality == :none ? [nil] : [:+, :-, nil]
+      permutations = [:+, :-, nil].product(trend_operations, season_operations)
+      optimum(permutations.map do |(op_1,op_2,op_3)|
+                new_opts = {}
+                set_value(new_opts, :alpha, model, op_1, change)
+                set_value(new_opts, :beta, model, op_2, change)
+                set_value(new_opts, :gamma, model, op_3, change)
+                model.improve(new_opts)
+              end)
+    end
+
+    def set_value(hsh, key, model, op, change)
+      unless op.nil?
+        new_value = model.send(key).send(op, change)
+        if new_value >= 0.0 && new_value <= 1.0
+          hsh[key] = new_value
+        end
+      end
+    end
+
+    def optimum(models)
+      models.min_by(&:mean_squared_error)
+    end
+    
+    def initial_models
+      initial_test_parameters.map do |parameters|
+        ExponentialSmoothingForecast.new(@time_series, @period, parameters)
+      end
+    end
+  end
+end

data/lib/tealeaves/exponential_smoothing_forecast.rb

@@ -0,0 +1,212 @@
+require 'tealeaves/forecast'
+
+module TeaLeaves
+  class ExponentialSmoothingForecast < Forecast
+    class SeasonalityStrategy
+      attr_reader :start_index
+
+      def initialize(period, gamma)
+        @gamma = gamma
+        @start_index = period
+      end
+
+      def new_values(observed_value, parameters, new_level)
+        new_seasonality = @gamma * t(observed_value, new_level) + 
+          (1 - @gamma) * parameters[:seasonality].first
+        parameters[:seasonality].drop(1) << new_seasonality
+      end
+    end
+
+    class AdditiveSeasonalityStrategy < SeasonalityStrategy
+      def p(value, params)
+        value - params[:seasonality].first
+      end
+
+      def t(value, new_level)
+        value - new_level
+      end
+
+      def apply(forecast, parameters, n)
+        index = (n - 1) % parameters[:seasonality].size
+        forecast + parameters[:seasonality][index]
+      end
+    end
+
+    class MultiplicativeSeasonalityStrategy < SeasonalityStrategy
+      def p(value, params)
+        value / params[:seasonality].first
+      end
+
+      def t(value, new_level)
+        value / new_level
+      end
+
+      def apply(forecast, parameters, n)
+        index = (n - 1) % parameters[:seasonality].size
+        forecast * parameters[:seasonality][index]
+      end
+    end
+    
+    class NoSeasonalityStrategy < SeasonalityStrategy
+      def p(value, params)
+        value
+      end
+
+      def t(value, new_level)
+      end
+      
+      def new_values(*args)
+        []
+      end
+
+      def start_index
+        1
+      end
+
+      def apply(forecast, parameters, n)
+        forecast
+      end
+    end
+
+    attr_reader :alpha, :beta, :gamma, :trend, :seasonality
+    
+    def initialize(time_series, period, opts={})
+      @time_series = time_series
+      @period = period
+      @alpha = opts[:alpha]
+      @beta  = opts[:beta]
+      @gamma = opts[:gamma]
+      @trend = opts[:trend]
+      @seasonality = opts[:seasonality]
+      @seasonality_strategy = case @seasonality
+                              when :none
+                                NoSeasonalityStrategy.new(@period, opts[:gamma])
+                              when :additive
+                                AdditiveSeasonalityStrategy.new(@period, opts[:gamma])
+                              when :multiplicative
+                                MultiplicativeSeasonalityStrategy.new(@period, opts[:gamma])
+                              end
+
+      calculate_one_step_ahead_forecasts
+    end
+
+    def improve(opts)
+      new_opts = {:alpha => @alpha, :beta => @beta, :gamma => @gamma, :trend => @trend, :seasonality => @seasonality}.merge(opts)
+      self.class.new(@time_series, @period, new_opts)
+    end
+    
+    attr_reader :model_parameters
+
+    def initial_level
+      @initial_level ||= @time_series.take(@period).inject(&:+).to_f / @period
+    end
+
+    def initial_trend
+      period_1, period_2 = @time_series.each_slice(@period).take(2)
+      period_1.zip(period_2).map {|(a,b)| (b - a) / @period.to_f }.inject(&:+) / @period
+    end
+
+    def initial_seasonal_indices
+      operation = @seasonality == :multiplicative ? :/ : :-
+      @time_series.take(@period).map {|v| v.to_f.send(operation, initial_level) }
+    end
+
+    def initial_parameters
+      { :level => initial_level,
+        :trend => initial_trend,
+        :seasonality => initial_seasonal_indices,
+        :index => @seasonality_strategy.start_index
+      }
+    end
+
+    def predict(n=nil)
+      if n.nil?
+        forecast(@model_parameters).first
+      else
+        (1..n).map {|i| forecast(@model_parameters, i).first }
+      end
+    end
+
+    # Returns the mean squared error of the forecast.
+    def mean_squared_error
+      return @mean_squared_error if @mean_squared_error
+
+      numerator = errors.drop(@seasonality_strategy.start_index).map {|i| i ** 2 }.inject(&:+)
+      @mean_squared_error = numerator / (errors.size - @seasonality_strategy.start_index).to_f
+    end
+
+    private
+
+    def calculate_one_step_ahead_forecasts
+      forecasts = [nil] * @seasonality_strategy.start_index
+      parameters = initial_parameters
+      (@seasonality_strategy.start_index...@time_series.size).each do |i|
+        forecast, parameters = forecast(parameters)
+        forecasts << forecast
+      end
+      parameters[:index] -= 1
+      @model_parameters = parameters
+      @one_step_ahead_forecasts = forecasts
+    end
+
+    def forecast(parameters, n=1)
+      new_params = {}
+      new_params[:level] = new_level(parameters)
+      new_params[:trend] = new_trend(parameters, new_params[:level])
+      new_params[:seasonality] = new_seasonality(parameters, new_params[:level])
+      new_params[:index] = parameters[:index] + 1
+      
+      pre_forecast = case @trend
+                     when :none
+                       parameters[:level]
+                     when :additive
+                       parameters[:level] + (n * parameters[:trend])
+                     when :multiplicative
+                       parameters[:level] * (parameters[:trend] ** n)
+                     end
+
+      forecast = @seasonality_strategy.apply(pre_forecast, parameters, n)
+      [forecast, new_params]
+    end
+
+    def new_level(parameters)
+      @alpha * p(parameters) + (1 - @alpha) * q(parameters)
+    end
+
+    def new_trend(parameters, new_level)
+      unless @trend == :none
+        @beta * r(parameters, new_level) + (1 - @beta) * parameters[:trend]
+      end
+    end
+
+    def new_seasonality(parameters, new_level)
+      @seasonality_strategy.new_values(@time_series[parameters[:index]],
+                                       parameters,
+                                       new_level)
+    end
+
+    def p(params)
+      @seasonality_strategy.p(@time_series[params[:index]], params)
+    end
+
+    def q(params)
+      case @trend
+      when :none
+        params[:level]
+      when :additive
+        params[:level] + params[:trend]
+      when :multiplicative
+        params[:level] * params[:trend]
+      end
+    end
+
+    def r(params, new_level)
+      case @trend
+      when :additive
+        new_level - params[:level]
+      when :multiplicative
+        new_level / params[:level]
+      end
+    end
+  end
+end

data/lib/tealeaves/forecast.rb

@@ -0,0 +1,22 @@
+module TeaLeaves
+  class Forecast
+    # Returns an array of 1 step ahead forecasts. The initial value in
+    # this array will be nil - there is no way of predicting the first
+    # value of the series.
+    attr_reader :one_step_ahead_forecasts
+
+    # Returns the errors between the observed values and the one step
+    # ahead forecasts.
+    def errors
+      @errors ||= @time_series.zip(one_step_ahead_forecasts).map do |(observation, forecast)|
+        forecast - observation if forecast && observation
+      end
+    end
+
+    # Returns the mean squared error of the forecast.
+    def mean_squared_error
+      numerator = errors.drop(1).map {|i| i ** 2 }.inject(&:+)
+      numerator / (errors.size - 1).to_f
+    end
+  end
+end

data/lib/tealeaves/moving_average.rb

@@ -0,0 +1,110 @@
+module TeaLeaves  
+  # A calculator for simple & weighted moving averages.
+  class MovingAverage
+    attr_reader :weights, :span
+
+    # Returns a Weighted Moving Average calculator, given a list of
+    # weights. 
+    #
+    # The list of weights should be an odd length, and should sum to
+    # 1.
+    #
+    # Examples:
+    #
+    #    MovingAverage.weighted([0.15, 0.7, 0.15]) # => [0.2, 0.7, 0.1]
+    #
+    def self.weighted(weights)
+      new(weights)
+    end
+
+    # Returns a Simple Moving Average calculator, given a span n.
+    # 
+    # Examples:
+    #  
+    #    MovingAverage.simple(5).weights # => [0.2, 0.2, 0.2, 0.2, 0.2]
+    #
+    # @param [Integer] n the span or order of the moving average,
+    #   i.e. the number of terms to include in each average.
+    def self.simple(n)
+      raise ArgumentError.new("Number of terms must be positive") if n < 1
+      weights = n.odd?() ? [1.0 / n] * n : expand_weights([1.0 / n] * (n / 2) + [1.0 / (2 * n)])
+      new weights
+    end
+
+
+    # Returns a moving average of a moving average calculator.
+    #
+    # For Example, for a 3x3 MA:
+    # 
+    #     MovingAverage.multiple(3,3).weights #=> [1/9, 2/9, 1/3, 2/9, 1/9]
+    #
+    def self.multiple(m,n)
+      divisor = (m * n).to_f
+      weights = (1..m).map {|i| i / divisor }
+      num_of_center_weights = ((m + n) / 2) - m
+      num_of_center_weights = 0 if num_of_center_weights < 0
+      num_of_center_weights.times { weights << weights.last }
+      
+      new(expand_weights(weights.reverse))
+    end
+
+    # Creates a new MovingAverage given a list of weights.
+    #
+    # See also the class methods simple and weighted.
+    def initialize(weights)
+      @weights = weights
+      @span = @weights.length
+      check_weights
+    end
+    
+    # Calculates the moving average for the given array of numbers.
+    #
+    # Moving averages won't include values for terms at the beginning or end of
+    # the array, so there will be fewer numbers than in the original.
+    def calculate(array)
+      return [] if @span > array.length
+      
+      array.each_cons(@span).map do |window|
+        window.zip(weights).map {|(a,b)| a * b }.inject(&:+)
+      end
+    end
+    
+    private
+    
+    # Error checking for weights
+    def check_weights
+      raise ArgumentError.new("Weights should be an odd list") unless @span.odd?
+      sum = weights.inject(&:+)
+      if sum < 0.999999 || sum > 1.000001
+        raise ArgumentError.new("Weights must sum to 1")
+      end
+    end
+
+    def self.expand_weights(weights)
+      left_side_weights = weights.reverse
+      left_side_weights.pop
+      left_side_weights + weights
+    end
+  end
+
+  module ArrayMethods
+    # Returns a moving average for this array, given either a number
+    # of terms or a list of weights.
+    #
+    # See MovingAverage for more detail.
+    # 
+    def moving_average(average_specifier)
+      if average_specifier.kind_of?(Array)
+        avg = MovingAverage.weighted(average_specifier)
+      elsif average_specifier.kind_of?(Integer)
+        avg = MovingAverage.simple(average_specifier)
+      else
+        raise ArgumentError.new("Unknown weights")
+      end
+      
+      avg.calculate(self)
+    end
+  end
+end
+
+Array.send(:include, TeaLeaves::ArrayMethods)

data/lib/tealeaves/naive_forecast.rb

@@ -0,0 +1,30 @@
+require 'tealeaves/forecast'
+
+module TeaLeaves
+  # A naive model just uses the current period's value as the
+  # prediction for the next period, i.e. F_t+1 = Y_t
+  class NaiveForecast < Forecast
+    # Creates a naive forecasting model for the given time series.
+    def initialize(time_series)
+      @time_series = time_series
+      @one_step_ahead_forecasts = [nil] + time_series
+      @one_step_ahead_forecasts.pop
+    end
+
+    # Returns Thiel's U Statistic. By definition, this is 1 for the
+    # Naive method.
+    def u_statistic
+      1
+    end
+
+    # Returns a prediction for the next period, or for the next n
+    # periods.
+    def predict(n=nil)
+      if n.nil?
+        @time_series.last
+      else
+        [@time_series.last] * n
+      end
+    end
+  end
+end

data/lib/tealeaves/seasonal_components.rb

@@ -0,0 +1,28 @@
+module TeaLeaves
+  class SeasonalComponents
+    def initialize(period, data)
+      @period = period
+      @data = data
+    end
+
+    def seasonal_averages
+      @seasonal_averages ||= seasonal_groups.map do |group| 
+        group.inject(&:+) / group.size.to_f
+      end
+    end
+    
+    def seasonal_factors(operation = :-)
+      @seasonal_factors ||= seasonal_averages.map {|i| i.send(operation, avg) }
+    end
+
+    private
+
+    def avg
+      @avg ||= seasonal_averages.inject(&:+) / @period.to_f
+    end
+
+    def seasonal_groups
+      @data.take(@period).zip( *(@data.drop(@period).each_slice(@period)) ).map(&:compact)
+    end
+  end
+end

data/lib/tealeaves/single_exponential_smoothing_forecast.rb

@@ -0,0 +1,28 @@
+require 'tealeaves/forecast'
+
+module TeaLeaves
+  class SingleExponentialSmoothingForecast < Forecast
+    def initialize(time_series, alpha)
+      @time_series = time_series
+      @alpha = alpha
+
+      @one_step_ahead_forecasts = [nil]
+
+      ([@time_series.first] + @time_series).inject do |a,b|
+        value = (1 - @alpha) * a + @alpha * b
+        @one_step_ahead_forecasts << value
+        value
+      end
+
+      @prediction = @one_step_ahead_forecasts.pop
+    end
+
+    def predict(n=nil)
+      if n.nil?
+        @prediction
+      else
+        [@prediction] * n
+      end
+    end
+  end
+end

data/spec/brute_force_optimization_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe TeaLeaves::BruteForceOptimization do
+  it "should have 1014 initial test models" do
+    described_class.new([1,2,3,4], 1).initial_test_parameters.size.should == 1014
+  end
+
+  it "should produce an initial model" do
+
+  end
+end

data/spec/exponential_smoothing_forecast_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe TeaLeaves::ExponentialSmoothingForecast do
+  before :each do
+    @time_series = [1,2,3,5,
+                    3,4,5,8,
+                    6,7,8,10]
+    @options  = {
+      :seasonality => :additive,
+      :trend => :additive,
+      :alpha => 0.7,
+      :beta => 0.1,
+      :gamma => 0.1
+    }
+    @forecast = described_class.new(@time_series, 4, @options)
+  end
+
+  it "should have an initial level of 11 / 4" do
+    @forecast.initial_level.
+      should be_within(0.001).of(11.0 / 4.0)
+  end
+
+  it "should have an initial trend" do
+    @forecast.initial_trend.
+      should be_within(0.0001).of(0.5625)
+  end
+
+  # [1 / (11/4.0), 2 / (11/4.0), 3 / (11/4.0), 5 / (11/4.0)]
+  it "should have initial seasonal indices for additive seasonality" do
+    @forecast.initial_seasonal_indices.should == [1 - (11/4.0), 2 - (11/4.0), 3 - (11/4.0), 5 - (11/4.0)]
+  end
+
+  it "should have initial seasonal indices for additive seasonality" do
+    @options[:seasonality] = :multiplicative
+    @forecast = described_class.new(@time_series, 4, @options)
+    @forecast.initial_seasonal_indices.should == [1 / (11/4.0), 2 / (11/4.0), 3 / (11/4.0), 5 / (11/4.0)]
+  end
+
+  it "should generate forecasts" do
+    data = [362,
+            385,
+            432,
+            341,
+            382,
+            409,
+            498,
+            387,
+            473,
+            513,
+            582,
+            474]
+
+    @forecast = described_class.new(data, 4, 
+                                    :alpha => 0.822,
+                                    :beta  => 0.055,
+                                    :gamma => 0.0,
+                                    :trend => :additive,
+                                    :seasonality => :multiplicative)
+
+    @forecast.initial_level.should == 380
+    @forecast.initial_trend.should == 9.75
+    @forecast.initial_seasonal_indices.zip([0.953, 1.013, 1.137, 0.897]).each do |(observed, expected)|
+      observed.should be_within(0.001).of(expected)
+    end
+
+    expected_values = [371.29, 414.64, 471.43, 399.3, 423.11, 506.60, 589.26, 471.93]
+    @forecast.one_step_ahead_forecasts.drop(4).zip(expected_values).each do |(observed, expected)|
+      observed.should be_within(0.03).of(expected)
+    end
+  end
+
+  it "should predict new values" do
+    @forecast.predict(4).zip([6.9, 8.4, 9.9, 12.5]).each do |(observed, expected)|
+      observed.should be_within(0.1).of(expected)
+    end
+  end
+end

data/spec/moving_average_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe TeaLeaves::MovingAverage do
+  it "should mix a #moving_average method into Array that takes a span" do
+    [0,1,2,6,4].moving_average(3).should == [1,3,4]
+  end
+
+  it "should mix a #moving_average method into Array that takes weights" do
+    [0,1,2,6,4].moving_average([0.2,0.6,0.2]).should == [1.0, 2.6, 4.8]
+  end
+
+  describe "a Simple Moving Average" do
+    it "should raise an ArgumentError if number of terms is < 1" do
+      lambda { described_class.simple(0) }.should raise_error(ArgumentError)
+    end
+    
+    it "should have equal weights with an odd number of terms" do
+      described_class.simple(5).weights.should == [0.2, 0.2, 0.2, 0.2, 0.2]
+    end
+    
+    it "should have have half weights at the ends with an even number of terms" do
+      described_class.simple(4).weights.should == [0.125, 0.25, 0.25, 0.25, 0.125]
+    end
+    
+    it "should return 3 averages from #calculate with a 3 point MA over 5 terms" do
+      described_class.simple(3).calculate([0,1,2,6,4]).should == [1,3,4]
+    end
+    
+    it "should return 1 average from #calculate with a 4 point MA over 5 terms" do
+      described_class.simple(4).calculate([0,1,2,6,4]).should == [2.75]
+    end
+    
+    it "should return no averages from #calculate with a 7 point MA over 5 terms" do
+      described_class.simple(7).calculate([0,1,2,6,4]).should == []
+    end
+  end
+
+  describe "a Weighted Moving Average" do
+    it "raises an Argument error if the weights do not sum to 1" do
+      expect { described_class.weighted([0.5, 0.5, 0.1]) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an Argument error if the list of weights is not odd sized" do
+      expect { described_class.weighted([0.5, 0.5]) }.to raise_error(ArgumentError)
+    end
+        
+    it "should allow asymmetric weights" do
+      described_class.weighted([0.6, 0.3, 0.1]).weights == [0.6, 0.3, 0.1]
+    end
+  end
+
+  describe "a Mutliple Moving Average" do
+    it "should combine weights in the 3x3 case" do
+      described_class.multiple(3,3).weights.should == [1.0/9, 2.0/9, 3.0/9, 2.0/9, 1.0/9]
+    end
+    
+    it "should combine weights in the 3x5 case" do
+      described_class.multiple(3,5).weights.should == [1.0/15, 2.0/15, 0.2, 0.2, 0.2, 2.0/15, 1.0/15]
+    end
+  end
+end

data/spec/naive_forecast_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe TeaLeaves::NaiveForecast do
+  before :each do
+    @time_series = [1,2,3]
+  end
+
+  it "provides forecasts such that F_t+1 = Y_t" do
+    described_class.new(@time_series).one_step_ahead_forecasts.should == [nil, 1, 2]
+  end
+
+  it "returns errors between one step ahead forecasts and observed values" do
+    described_class.new(@time_series).errors.should == [nil, -1, -1]
+  end
+
+  it "returns a prediction for the next value in the series" do
+    described_class.new(@time_series).predict.should == 3
+  end
+
+  it "returns n predictions for the next values, all the same" do
+    described_class.new(@time_series).predict(4).should == [3,3,3,3]
+  end
+
+  it "returns 1 as Thiel's U Statistic" do
+    described_class.new(@time_series).u_statistic.should == 1
+  end
+end

data/spec/seasonal_components_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe TeaLeaves::SeasonalComponents do
+  it "returns seasonal averages for a period" do
+    described_class.new(4, [1,2,1,3,2,4,1,9]).seasonal_averages.
+      should == [1.5, 3, 1, 6]
+  end
+
+  it "returns seasonal averages for a period, with ragged data" do
+    described_class.new(4, [1,2,1,3,2,4,1,9, 3]).seasonal_averages.
+      should == [2, 3, 1, 6]
+  end
+
+  it "returns seasonal weights" do
+    described_class.new(4, [1,2,1,3,2,4,1,9,3]).seasonal_factors.
+      should == [-1.0, 0.0, -2.0, 3.0]
+  end
+end

data/spec/single_exponential_smoothing_forecast_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe TeaLeaves::SingleExponentialSmoothingForecast do
+  before :each do
+    @time_series = [1,2,3]
+  end
+
+  it "should generate one step ahead forecasts" do
+    described_class.new(@time_series, 0.7).one_step_ahead_forecasts.
+      should == [nil, 0.7 * 1 + 0.3 * 1, 0.7 * 2 + 0.3 * 1] 
+  end
+
+  it "has one step ahead errors" do
+    described_class.new(@time_series, 0.7).errors.should == [nil, -1, -1.3]
+  end
+
+  it "has a predicition for the next period" do
+    described_class.new(@time_series, 0.7).predict.should == 0.7 * 3 + 0.3 * 1.7
+  end
+
+  it "has a predicition for the n next periods" do
+    described_class.new(@time_series, 0.7).predict(2).should == [0.7 * 3 + 0.3 * 1.7] * 2
+  end
+
+  it "calculates mean squared error" do
+    described_class.new(@time_series, 0.7).mean_squared_error.should be_within(0.001).of(1.345)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'tealeaves'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|  
+end

data/tealeaves.gemspec

@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "tealeaves"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roland Swingler"]
+  s.date = "2012-02-21"
+  s.description = "Exponential smoothing based forecasting methods for time series data"
+  s.email = "roland.swingler@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/tealeaves.rb",
+    "lib/tealeaves/brute_force_optimization.rb",
+    "lib/tealeaves/exponential_smoothing_forecast.rb",
+    "lib/tealeaves/forecast.rb",
+    "lib/tealeaves/moving_average.rb",
+    "lib/tealeaves/naive_forecast.rb",
+    "lib/tealeaves/seasonal_components.rb",
+    "lib/tealeaves/single_exponential_smoothing_forecast.rb",
+    "spec/brute_force_optimization_spec.rb",
+    "spec/exponential_smoothing_forecast_spec.rb",
+    "spec/moving_average_spec.rb",
+    "spec/naive_forecast_spec.rb",
+    "spec/seasonal_components_spec.rb",
+    "spec/single_exponential_smoothing_forecast_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb",
+    "tealeaves.gemspec"
+  ]
+  s.homepage = "http://github.com/knaveofdiamonds/tealeaves"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Simple Forecasting Methods in Ruby"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.7"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<yard>, ["~> 0.7"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<yard>, ["~> 0.7"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification 
+name: tealeaves
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Roland Swingler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  prerelease: false
+  type: :development
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  name: rspec
+  prerelease: false
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 7
+        version: "0.7"
+  name: yard
+  prerelease: false
+  type: :development
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  name: rdoc
+  prerelease: false
+  type: :development
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  prerelease: false
+  type: :development
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 1
+        - 8
+        - 3
+        version: 1.8.3
+  name: jeweler
+  prerelease: false
+  type: :development
+  requirement: *id006
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  prerelease: false
+  type: :development
+  requirement: *id007
+description: Exponential smoothing based forecasting methods for time series data
+email: roland.swingler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/tealeaves.rb
+- lib/tealeaves/brute_force_optimization.rb
+- lib/tealeaves/exponential_smoothing_forecast.rb
+- lib/tealeaves/forecast.rb
+- lib/tealeaves/moving_average.rb
+- lib/tealeaves/naive_forecast.rb
+- lib/tealeaves/seasonal_components.rb
+- lib/tealeaves/single_exponential_smoothing_forecast.rb
+- spec/brute_force_optimization_spec.rb
+- spec/exponential_smoothing_forecast_spec.rb
+- spec/moving_average_spec.rb
+- spec/naive_forecast_spec.rb
+- spec/seasonal_components_spec.rb
+- spec/single_exponential_smoothing_forecast_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tealeaves.gemspec
+homepage: http://github.com/knaveofdiamonds/tealeaves
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple Forecasting Methods in Ruby
+test_files: []
+