signal_tools 0.2.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Matt White
+
+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,39 @@
+== Signal Tools
+
+Signal tools allows you to create technical analysis data for a given stock (like MACD, stochastic, and exponential moving averages).
+
+== Installation
+
+gem install signal_tools
+bundle install --without development test
+
+== Usage
+
+require 'signal_tools'
+
+stock = SignalTools::Stock.new('GOOG', '2010-01-01', '2010-05-31')
+# Leave the last parameter blank to get from a previous date up until today:
+stock = SignalTools::Stock.new('GOOG', '2010-01-01')
+# Leave both dates blank to get the past 90 days:
+stock = SignalTools::Stock.new('GOOG')
+
+# Generate MACD signal with an 8 day short period, 17 day long period, and 9 day EMA signal period:
+stock.macd(8, 17, 9)
+
+# Generate slow stochastic signal with a 14 day K period and a 5 day D period:
+stock.slow_stochastic(14, 5)
+
+== 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 Matt White. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+#task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "signal_tools #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/signal_tools/stock.rb

@@ -0,0 +1,309 @@
+module SignalTools
+  class Stock
+    Default_Period = 90
+    EMA_Seed_Days = 10
+    Slow_K_SMA = 3
+    ATR_Seed_Days = 14
+
+    attr_accessor :ticker
+    attr_reader :stock_data
+
+    def initialize(ticker, from_date=Date.today-Default_Period, to_date=Date.today)
+      from_date = Date.parse(from_date) unless from_date.is_a?(Date)
+      to_date = Date.parse(to_date) unless to_date.is_a?(Date)
+      @ticker = ticker
+      @stock_data = SignalTools::StockData.new(ticker, from_date, to_date)
+    end
+
+    def dates
+      @stock_data.dates
+    end
+
+    # Takes a period of days over which to average closing prices and returns the exponential moving average for each day.
+    def ema(period=10)
+      trim_data_to_range(ema_points(period, @stock_data.close_prices))
+    end
+
+    def macd(fast=8, slow=17, signal=9)
+      trim_data_to_range(macd_points(fast, slow, signal))
+    end
+
+    def fast_stochastic(k=14, d=5)
+      trim_data_to_range(fast_stochastic_points(k, d))
+    end
+
+    def slow_stochastic(k=14, d=5)
+      trim_data_to_range(slow_stochastic_points(k, d))
+    end
+
+    def atr(period=14)
+      trim_data_to_range(average_true_ranges(period))
+    end
+
+    def adx(period=14)
+      trim_data_to_range(average_directional_indexes(period))
+    end
+
+    private
+
+    #### EMA methods
+
+    def ema_points(period, data, type=:default)
+      emas = [default_simple_average(data, EMA_Seed_Days)]
+      if type == :wilder
+        data.slice(EMA_Seed_Days..-1).each { |current| emas << calculate_wilder_ema(emas.last, current, period) }
+      else
+        data.slice(EMA_Seed_Days..-1).each { |current| emas << calculate_ema(emas.last, current, period) }
+      end
+      emas
+    end
+
+    #Takes current value, previous day's EMA, and number of days. Returns EMA for that day.
+    def calculate_ema(previous, current, period)
+      (current - previous) * (2.0 / (period + 1)) + previous
+    end
+
+    #Uses Wilder's moving average formula.
+    def calculate_wilder_ema(previous, current, period)
+      (previous * (period - 1) + current) / period
+    end
+
+    #Takes a period and array of data and calculates the sum ema over the period specified.
+    def period_sum_ema(period, data)
+      raise if data.size <= period
+      sum_emas = [SignalTools.sum(data[0...period])]
+      data[(period..-1)].each do |today|
+        sum_emas << (sum_emas.last - (sum_emas.last / period) + today)
+      end
+      sum_emas
+    end
+
+    #### MACD Methods
+
+    # Takes a period of days for fast, slow, signal, and time period (eg 8,17,9).
+    def macd_points(fast, slow, signal)
+      fast_ema_points = ema_points(fast, @stock_data.close_prices)
+      slow_ema_points = ema_points(slow, @stock_data.close_prices)
+      macd_and_divergence_points(fast_ema_points, slow_ema_points, signal)
+    end
+
+    def macd_and_divergence_points(fast_ema_points, slow_ema_points, signal)
+      macds = differences_between_arrays(fast_ema_points, slow_ema_points)
+      signal_points = ema_points(signal, macds)
+      divergences = differences_between_arrays(macds, signal_points)
+      {:signal_points => signal_points, :divergences => divergences}
+    end
+
+    # Returns an array with the differences between the first_points and second_points
+    def differences_between_arrays(first_points, second_points)
+      SignalTools.truncate_to_shortest!(first_points, second_points)
+      differences = []
+      first_points.each_with_index { |fp, index| differences << fp - second_points[index] }
+      differences
+    end
+
+    #### Stochastic Methods
+
+    def fast_stochastic_points(k_period, d_period)
+      k_points = calculate_fast_stochastic_k_points(k_period)
+      d_points = calculate_d_points(k_points, d_period)
+      k_d_points(k_points, d_points)
+    end
+
+    def slow_stochastic_points(k_period, d_period)
+      fast_points = fast_stochastic_points(k_period, d_period)
+      k_points = slow_k_points(fast_points[:k])
+      slow_d_points = calculate_d_points(k_points, d_period)
+      k_d_points(k_points, slow_d_points)
+    end
+
+    def calculate_fast_stochastic_k_points(period)
+      index = 0
+      points = []
+      while((index + period) <= @stock_data.close_prices.size)
+        today_cp = @stock_data.close_prices[index + period - 1]
+        low_price = get_for_period(@stock_data.low_prices, index, index + period - 1, :min)
+        high_price = get_for_period(@stock_data.high_prices, index, index + period - 1, :max)
+        points << (today_cp - low_price) / (high_price - low_price)
+        index += 1
+      end
+      points
+    end
+
+    def calculate_d_points(k_points, period)
+      collection_for_array(k_points, period, :average)
+    end
+
+    def k_d_points(k_points, d_points)
+      raise unless k_points.size > d_points.size
+      SignalTools.truncate_to_shortest!(k_points, d_points)
+      {:k => k_points, :d => d_points}
+    end
+
+    def slow_k_points(fast_k_points)
+      collection_for_array(fast_k_points, Slow_K_SMA, :average)
+    end
+
+    #### True Range Methods
+
+     # Takes a smoothing period and historical data and calculates the average
+     # true ranges.
+    def average_true_ranges(period)
+      trs = true_ranges
+      atrs = [default_simple_average(trs.slice!(0...ATR_Seed_Days), ATR_Seed_Days)]
+      trs.each { |tr| atrs << calculate_average_true_range(atrs.last, tr, period) }
+      atrs
+    end
+
+    # Takes historical data and computes the true ranges.
+    def true_ranges
+      trs = [@stock_data.high_prices.first - @stock_data.low_prices.first]
+      index = 1
+      while index < (@stock_data.high_prices.size)
+        trs << true_range(@stock_data.raw_data[index], @stock_data.raw_data[index-1])
+        index += 1
+      end
+      trs
+    end
+
+    # Takes today's data and yesterday's data and computes the true range.
+    def true_range(today, yesterday)
+      [
+        today[SignalTools::StockData::Indexes[:high]] - today[SignalTools::StockData::Indexes[:low]],
+        (yesterday[SignalTools::StockData::Indexes[:close]] - today[SignalTools::StockData::Indexes[:high]]).abs,
+        (yesterday[SignalTools::StockData::Indexes[:close]] - today[SignalTools::StockData::Indexes[:low]]).abs
+      ].max
+    end
+
+    # Takes yesterday's average true range, today's true range, and the smoothing
+    # period and calculates the day's average true range.
+    def calculate_average_true_range(yesterday_atr, today_tr, period)
+      (yesterday_atr * (period - 1) + today_tr) / period
+    end
+
+    #### Average Directional Index Methods
+
+    def average_directional_indexes(period)
+      dxs = directional_indexes(plus_directional_index(period), minus_directional_index(period))
+      adxs = ema_points(period, dxs, :wilder)
+      adxs
+    end
+
+    def directional_indexes(plus_dis, minus_dis)
+      SignalTools.truncate_to_shortest!(plus_dis, minus_dis)
+      differences, sums = [], []
+      index = 0
+      while index < plus_dis.size
+        differences << (plus_dis[index] - minus_dis[index]).abs
+        sums << (plus_dis[index] + minus_dis[index])
+        index += 1
+      end
+      quotients(differences, sums)
+    end
+
+    def plus_directional_index(period)
+      plus_dms = plus_directional_movement(@stock_data.raw_data)
+      plus_dm_sums = period_sum_ema(period, plus_dms)
+      true_range_sums = period_sum_ema(period, true_ranges)
+      quotients(plus_dm_sums, true_range_sums)
+    end
+
+    def minus_directional_index(period)
+      minus_dms = minus_directional_movement(@stock_data.raw_data)
+      minus_dm_sums = period_sum_ema(period, minus_dms)
+      true_range_sums = period_sum_ema(period, true_ranges)
+      quotients(minus_dm_sums, true_range_sums)
+    end
+
+    def quotients(first, second)
+      SignalTools.truncate_to_shortest!(first, second)
+      index = 0
+      quots = []
+      while index < first.size
+        quots << first[index] / second[index]
+        index += 1
+      end
+      quots
+    end
+
+    def plus_directional_movement(data)
+      plus_dm = []
+      data.each_cons(2) do |two_days|
+        um = up_move(two_days.last, two_days.first)
+        dm = down_move(two_days.last, two_days.first)
+        plus_dm << ((um > dm) ? um : 0)
+      end
+      plus_dm
+    end
+
+    def minus_directional_movement(data)
+      minus_dm = []
+      data.each_cons(2) do |two_days|
+        um = up_move(two_days.last, two_days.first)
+        dm = down_move(two_days.last, two_days.first)
+        minus_dm << ((dm > um) ? dm : 0)
+      end
+      minus_dm
+    end
+
+#TODO: Pass in only the high prices to this method
+    # Up move is today_high - yesterday_high
+    def up_move(today, yesterday)
+      diff = today[SignalTools::StockData::Indexes[:high]] - yesterday[SignalTools::StockData::Indexes[:high]]
+      diff > 0 ? diff : 0
+    end
+
+#TODO: Pass in only the low prices to this method
+    # Down move is yesterday_low - today_low
+    def down_move(today, yesterday)
+      diff = yesterday[SignalTools::StockData::Indexes[:low]] - today[SignalTools::StockData::Indexes[:low]]
+      diff > 0 ? diff : 0
+    end
+
+    #### Misc Utility Methods
+
+    # Returns only the points specific to the date range given.
+    def trim_data_to_range(data)
+      if data.is_a? Array
+        data.slice!(0...(-dates.size))
+      elsif data.is_a? Hash
+        data.each { |k,v| v = v.slice!(0...(-dates.size)) }
+      end
+      data
+    end
+
+    # Gets the first 0...period of numbers from data and returns a simple average.
+    def default_simple_average(data, period)
+      SignalTools.average(data.slice(0...period))
+    end
+
+    #Runs method for the given slice of the array.
+    def get_for_period(points, start, finish, method)
+      case method
+        when :average
+          SignalTools.average(points.slice(start..finish))
+        else
+          (points.slice(start..finish)).send(method)
+        end
+    end
+
+    #Returns a collection of values by iterating over an array, slicing it period
+    # elements at a time and calling method for each slice.
+    def collection_for_array(points, period, method)
+      raise unless points.size >= period
+      collection = []
+      index = 0
+      while((index + period - 1) < points.size)
+        collection << get_for_period(points, index, (index + period - 1), method)
+        index += 1
+      end
+      collection
+    end
+
+    def matching_dates(array)
+      dates = @stock_data.dates.dup
+      SignalTools.truncate_to_shortest!(dates, array)
+      @dates = dates
+    end
+  end
+end

data/lib/signal_tools/stock_data.rb

@@ -0,0 +1,75 @@
+require 'yahoofinance'
+
+module SignalTools
+  class StockData
+    # Extra days needed to produce accurate data for the desired date.
+    Extra_Days = 365
+    Indexes = {
+      :date           => 0,
+      :open           => 1,
+      :high           => 2,
+      :low            => 3,
+      :close          => 4,
+#Presently unused
+#      :volume         => 5,
+#      :adjusted_close => 6
+    }
+    attr_reader :raw_data, :dates
+
+    #Downloads historical prices using the YahooFinance gem.
+    def initialize(ticker, from_date, to_date)
+      @from_date = from_date
+      @raw_data = YahooFinance::get_historical_quotes(ticker, @from_date-Extra_Days, to_date).reverse
+      convert_raw_data_strings!
+      # We will never have need of the extraneous dates so we trim here
+      @dates = trim_dates
+    end
+
+    def open_prices
+      @open_prices ||= @raw_data.map { |d| d[Indexes[:open]] }
+    end
+
+    def high_prices
+      @high_prices ||= @raw_data.map { |d| d[Indexes[:high]] }
+    end
+
+    def low_prices
+      @low_prices ||= @raw_data.map { |d| d[Indexes[:low]] }
+    end
+
+    def close_prices
+      @close_prices ||= @raw_data.map { |d| d[Indexes[:close]] }
+    end
+
+    private
+
+    def convert_raw_data_strings!(*indexes)
+      @raw_data.each do |datum|
+        datum[Indexes[:date]] = Date.parse(datum[Indexes[:date]])
+        datum[Indexes[:open]] = datum[Indexes[:open]].to_f
+        datum[Indexes[:high]] = datum[Indexes[:high]].to_f
+        datum[Indexes[:low]] = datum[Indexes[:low]].to_f
+        datum[Indexes[:close]] = datum[Indexes[:close]].to_f
+      end
+    end
+
+    def trim_dates
+      dates = @raw_data.map { |d| d[Indexes[:date]] }
+      index = binary_search_for_date_index(dates)
+      dates[index..-1]
+    end
+
+    # Performs a binary search for @from_date on @dates. Returns the index of @from_date.
+    def binary_search_for_date_index(dates, low=0, high=dates.size-1)
+      return low if high <= low    # closest match
+      mid = low + (high - low) / 2
+      if dates[mid] > @from_date
+        binary_search_for_date_index(dates, low, mid-1)
+      elsif dates[mid] < @from_date
+        binary_search_for_date_index(dates, mid+1, high)
+      else
+        mid
+      end
+    end
+  end
+end

data/lib/signal_tools.rb

@@ -0,0 +1,22 @@
+require File.expand_path("../signal_tools/stock_data", __FILE__)
+require File.expand_path("../signal_tools/stock", __FILE__)
+
+module SignalTools
+  VERSION = '0.2.0'
+
+  def self.sum(array)
+    array.inject(0) {|accum, c| accum + c.to_f }
+  end
+
+  def self.average(array)
+    return nil if !array || array.size == 0
+    sum(array).to_f / array.size
+  end
+
+  # Truncates all arrays to the size of the shortest array by cutting off the front
+  # of the longer arrays.
+  def self.truncate_to_shortest!(*arrays)
+    shortest_size = arrays.inject(arrays.first.size) { |size, array| array.size < size ? array.size : size }
+    arrays.each { |array| array.slice!(0...(array.size - shortest_size)) }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'test/unit'
+require 'flexmock/test_unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'signal_tools'
+
+class Test::Unit::TestCase
+  def data_for_tests(period)
+    repeat = 5
+    historical_data = []
+    (0...SignalTools::StockData::Extra_Days+period).each do |i|
+      seed = i % repeat + 1
+      historical_data << [
+        (Date.today-i).to_s,
+        (seed * 0.8).to_s, #Open
+        (seed * 1.5).to_s, #High
+        (seed * 0.5).to_s, #Low
+        (seed * 0.9).to_s  #Close
+      ]
+    end
+    historical_data
+  end
+end

data/test/test_signal_tools.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require 'signal_tools'
+
+class TestSignalTools < Test::Unit::TestCase
+  def setup
+    @array1 = [1,2,3,4,5,6,7,8,9,10]
+  end
+
+  def test_sum_returns_the_correct_sum_of_array_elements
+    assert_equal(55, SignalTools::sum(@array1))
+  end
+
+  def test_average_returns_the_correct_average_of_array_elements
+    assert_equal(5.5, SignalTools::average(@array1))
+  end
+
+  def test_truncate_to_shortest_returns_two_arrays_of_equal_size
+    array2 = [1,2,3]
+    SignalTools::truncate_to_shortest!(@array1, array2)
+    assert_equal(@array1.size, array2.size)
+  end
+end

data/test/test_stock.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+require 'signal_tools'
+
+class TestStock < Test::Unit::TestCase
+  def setup
+    ticker = "TESTING"
+    @days = 90
+    flexmock(YahooFinance).should_receive(:get_historical_quotes).with_any_args.and_return(data_for_tests(@days))
+    @stock = SignalTools::Stock.new(ticker)
+  end
+
+  def test_ema
+    assert_equal "2.344948", "%.6f" % @stock.ema[-1]
+    assert_equal "2.736776", "%.6f" % @stock.ema[-5]
+    assert_equal "2.556322", "%.6f" % @stock.ema(25)[-1]
+    assert_equal "2.705835", "%.6f" % @stock.ema(25)[-5]
+  end
+
+  def test_macd
+    assert_equal "-0.034645", "%.6f" % @stock.macd[:signal_points][-1]
+    assert_equal "-0.018762", "%.6f" % @stock.macd[:signal_points][-5]
+    assert_equal "-0.195043", "%.6f" % @stock.macd[:divergences][-1]
+    assert_equal "0.063532",  "%.6f" % @stock.macd[:divergences][-5]
+
+    assert_equal "-0.022654", "%.6f" % @stock.macd(12, 26, 9)[:signal_points][-1]
+    assert_equal "-0.014099", "%.6f" % @stock.macd(12, 26, 9)[:signal_points][-5]
+    assert_equal "-0.136291", "%.6f" % @stock.macd(12, 26, 9)[:divergences][-1]
+    assert_equal "0.034219",  "%.6f" % @stock.macd(12, 26, 9)[:divergences][-5]
+  end
+
+  def test_fast_stochastic
+    assert_equal "0.057143", "%.6f" % @stock.fast_stochastic[:k][-1]
+    assert_equal "0.571429", "%.6f" % @stock.fast_stochastic[:k][-5]
+    assert_equal "0.314286", "%.6f" % @stock.fast_stochastic[:d][-1]
+    assert_equal "0.314286", "%.6f" % @stock.fast_stochastic[:d][-5]
+
+    assert_equal "0.057143", "%.6f" % @stock.fast_stochastic(12, 3)[:k][-1]
+    assert_equal "0.571429", "%.6f" % @stock.fast_stochastic(12, 3)[:k][-5]
+    assert_equal "0.185714", "%.6f" % @stock.fast_stochastic(12, 3)[:d][-1]
+    assert_equal "0.271429", "%.6f" % @stock.fast_stochastic(12, 3)[:d][-5]
+  end
+
+  def test_slow_stochastic
+    assert_equal "0.185714", "%.6f" % @stock.slow_stochastic[:k][-1]
+    assert_equal "0.271429", "%.6f" % @stock.slow_stochastic[:k][-5]
+    assert_equal "0.314286", "%.6f" % @stock.slow_stochastic[:d][-1]
+    assert_equal "0.314286", "%.6f" % @stock.slow_stochastic[:d][-5]
+
+    assert_equal "0.185714", "%.6f" % @stock.slow_stochastic(12, 3)[:k][-1]
+    assert_equal "0.271429", "%.6f" % @stock.slow_stochastic(12, 3)[:k][-5]
+    assert_equal "0.314286", "%.6f" % @stock.slow_stochastic(12, 3)[:d][-1]
+    assert_equal "0.257143", "%.6f" % @stock.slow_stochastic(12, 3)[:d][-5]
+  end
+
+  def test_atr
+    assert_equal "3.195750", "%.6f" % @stock.atr[-1]
+    assert_equal "3.438910", "%.6f" % @stock.atr[-5]
+    assert_equal "3.208282", "%.6f" % @stock.atr(15)[-1]
+    assert_equal "3.434397", "%.6f" % @stock.atr(15)[-5]
+  end
+
+  def test_adx
+    assert_equal "0.491321", "%.6f" % @stock.adx[-1]
+    assert_equal "0.496588", "%.6f" % @stock.adx[-5]
+  end
+
+  def test_stock_should_have_correct_number_of_data_elements
+    assert_equal(@days+1, @stock.dates.size)
+    assert_equal(@days+1, @stock.ema.size)
+    assert_equal(@days+1, @stock.macd[:divergences].size)
+    assert_equal(@days+1, @stock.fast_stochastic[:k].size)
+    assert_equal(@days+1, @stock.slow_stochastic[:k].size)
+    assert_equal(@days+1, @stock.atr.size)
+    assert_equal(@days+1, @stock.adx.size)
+  end
+end

data/test/test_stock_data.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'signal_tools'
+
+class TestStockData < Test::Unit::TestCase
+  def setup
+    ticker = "TESTING"
+    @days = 90
+    @total_days = @days + SignalTools::StockData::Extra_Days
+    @from_date = Date.today - @days
+    @to_date = Date.today
+    flexmock(YahooFinance).should_receive(:get_historical_quotes).with_any_args.and_return(data_for_tests(@days))
+    @stock_data = SignalTools::StockData.new(ticker, @from_date, @to_date)
+  end
+
+  def test_dates
+    new_dates = []
+    (0..@days).each { |i| new_dates.unshift((@to_date - i)) }
+    assert_equal new_dates, @stock_data.dates
+  end
+
+  def test_open_prices
+    result = @stock_data.open_prices.delete_if { |e| !e.is_a?(Float) }
+    assert_equal @total_days, result.size
+  end
+
+  def test_high_prices
+    result = @stock_data.high_prices.delete_if { |e| !e.is_a?(Float) }
+    assert_equal @total_days, result.size
+  end
+
+  def test_low_prices
+    result = @stock_data.low_prices.delete_if { |e| !e.is_a?(Float) }
+    assert_equal @total_days, result.size
+  end
+
+  def test_close_prices
+    result = @stock_data.close_prices.delete_if { |e| !e.is_a?(Float) }
+    assert_equal @total_days, result.size
+  end
+end

data/test/test_tickers

@@ -0,0 +1 @@
+JOSB DECK INFY NJ UA STEC VLCM CAAS QCOM CMG BLUD CAM CTSH AFAM DRQ SYNA STRA JCG ARO MIDD RMD ISRG WOOF CMTL MANT PCLN GME GPRO COH HS MCRS BOLT FLIR ABT

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: signal_tools
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Matt White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-05 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yahoofinance
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Gem to create technical analysis data for a given security (like MACD, stochastic, and exponential moving averages).
+email: mattw922@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/signal_tools/stock.rb
+- lib/signal_tools/stock_data.rb
+- lib/signal_tools.rb
+- test/test_signal_tools.rb
+- test/test_tickers
+- test/test_helper.rb
+- test/test_stock_data.rb
+- test/test_stock.rb
+- README.rdoc
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/whitethunder/signal_tools
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Create technical analysis data for a given stock.
+test_files: []
+