indicators 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.3
+  - 1.9.2
+script: "bundle exec rake"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in indicators.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Nedomas
+
+MIT License
+
+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.md

@@ -0,0 +1,93 @@
+# Indicators
+
+A gem for calculating technical analysis indicators.
+
+[![Build Status](https://secure.travis-ci.org/Nedomas/indicators.png)](http://travis-ci.org/Nedomas/indicators)
+
+Current functionality demo of Indicators and Securities gems synergy can be tested at http://strangemuseum.heroku.com.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'indicators'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install indicators
+
+## Accepted Input
+
+# Array
+
+	my_data = Indicators::Data.new([1, 2, 3, 4, 5])
+
+Then it returns data as an array with indicator values in index places:
+
+	i.e. my_data.calc(:type => :sma, :variables => 2) => [nil, 1.5, 2.5, 3.5, 4.5]
+
+# Securities gem hash
+
+	my_data = Indicators::Data.new(Securities::Stock.new(["aapl", "yhoo"]).history(:start_date => '2012-08-25', :end_date => '2012-08-30').results)
+
+Then it returns a hash so it can be quite powerful at calculating multiple stock indicators at once:
+
+	{"aapl"=>[nil, 675.24, 674.0600000000001], "yhoo"=>[nil, 14.785, 14.821666666666667]}
+
+## Supported Indicators
+
+# Simple Moving Average => :sma
+
+	my_data.calc(:type => :sma, :variables => 5)
+
+#	Exponental Moving Average => :ema
+
+	my_data.calc(:type => :ema, :variables => 5)
+
+# Bollinger Bands => :bb
+
+	my_data.calc(:type => :bb, :variables => [15, 3])
+
+Variables have to be specified as an array [periods, multiplier]. If multiplier isn't specified, it defaults to 2.
+
+	It returns output as an array for each data point [middle band, upper band, lower band].
+	i.e. my_data.calc(:type => :bb, :variables => 3) => {"aapl"=>[nil, nil, [674.65, 676.8752190903368, 672.4247809096631]]} 
+
+# Moving Average Convergence Divergence => :macd
+
+	my_data.calc(:type => :macd, :variables => [12, 26, 9])
+
+Variables have to be specified as an array [faster periods, slower periods, signal line]. If slower periods isn't specified, it defaults to 26 and signal line to 9.
+
+	MACD output is [MACD line, signal line, MACD histogram].
+
+# Relative Strength Index => :rsi
+
+	my_data.calc(:type => :rsi, :variables => 14)
+
+The more data it has, the more accurate RSI is.
+
+## To Do
+
+* Make defaults mechanism more versatile.
+* Write specs.
+* More validations.
+* A strategy backtesting tool.
+
+# Indicators:
+* More moving averages (CMA, WMA, MMA).
+* ROC.
+* CCI.
+* Stochastics.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/indicators.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/indicators/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Nedomas"]
+  gem.email         = ["domas.bitvinskas@me.com"]
+  gem.description   = %q{A gem for calculating technical analysis indicators.}
+  gem.summary       = %q{A gem for calculating technical analysis indicators.}
+  gem.homepage      = "http://github.com/Nedomas/indicators"
+
+  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.name          = "indicators"
+  gem.require_paths = ["lib"]
+  gem.version       = Indicators::VERSION
+
+  gem.add_dependency 'rails'
+  gem.add_development_dependency 'securities'
+  gem.add_development_dependency 'rspec'
+end

data/lib/indicators/data.rb

@@ -0,0 +1,45 @@
+module Indicators
+	class Data
+
+		attr_reader :data, :results
+		INDICATORS = [:sma, :ema, :bb, :macd, :rsi]
+		# Error handling
+		class DataException < StandardError
+		end
+
+		def initialize parameters
+			@data = parameters
+
+			# Check if data usable.
+			if @data.nil? || @data.empty?
+        raise DataException, "There is no data to work on."
+      end
+			unless @data.is_a?(Array) or @data.is_a?(Hash)
+				raise DataException, "Alien data. Given data must be an array or a hash (got #{@data.class})."
+			end
+
+			if @data.is_a?(Hash)
+				# Hacky, but a fast way to check if this is a dividends hash without the extra hassle.
+				raise DataException, "Cannot use dividends values for technical analysis." if @data.to_s.include?(':dividends')
+			end
+		end
+
+		def calc parameters
+			# Check is parameters are usable.
+			unless parameters.is_a?(Hash)
+				raise DataException, 'Given parameters have to be a hash. FORMAT: .calc(:type => :ema, :variables => 12)'
+			end
+
+			# If not specified, set default :type to :sma.
+			parameters[:type] = :sma if parameters[:type].nil? or parameters[:type].empty?
+
+			# Check if there is such indicator type supported.
+			case
+				when INDICATORS.include?(parameters[:type]) then @results = Indicators::Main.calculate(@data, parameters)
+			else 
+				raise DataException, "Invalid indicator type specified (#{parameters[:type]})."
+			end
+		end
+
+	end
+end

data/lib/indicators/main.rb

@@ -0,0 +1,305 @@
+module Indicators
+  #
+  # Moving averages
+	class Main
+
+    # Error handling.
+    class MainException < StandardError
+    end
+
+		def self.calculate data, parameters
+			if data.is_a?(Hash)
+        results = Hash.new
+        data.each do |symbol, stock_data|
+          # Check if this symbol was empty and don't go further with it.
+          if stock_data.length == 0
+            results[symbol] = []
+          else
+            results[symbol] = case parameters[:type]
+                                when :sma then sma(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+                                when :ema then ema(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+                                when :bb then bb(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+                                when :macd then macd(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+                                when :rsi then rsi(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+                              end
+            # Parser returns in {:date=>[2012.0, 2012.0, 2012.0], :open=>[409.4, 410.0, 414.95],} format
+          end
+        end
+			else
+				results = case parameters[:type]
+				            when :sma then sma(data, parameters[:variables])
+                    when :ema then ema(data, parameters[:variables])
+                    when :bb then bb(data, parameters[:variables])
+                    when :macd then macd(data, parameters[:variables])
+                    when :rsi then rsi(data, parameters[:variables])
+				          end
+			end
+			return results
+    end
+
+    private
+
+      def self.get_data data, variables, column
+        # If this is a hash, choose which column of values to use for calculations.
+        if data.is_a?(Hash)
+          usable_data = data[column]
+        else
+          usable_data = data
+        end
+
+        if usable_data.length < variables
+          raise MainException, "Data point length (#{usable_data.length}) must be greater or equal to the needed periods value (#{variables})."
+        end
+        return usable_data
+      end
+
+      def self.get_variables variables, i=0, default=0
+        if variables.is_a?(Array)
+          # In case array is given not like [1, 2] but like this ["1", "2"]. This usually happens when getting data from input forms.
+          variables = variables.map(&:to_i)
+          if variables.length < 2
+            return default if i != 0
+            return variables[0]
+          else
+            if variables[i].nil? then return default else return variables[i] end
+          end
+        else
+          return default if i != 0
+          return variables
+        end
+      end
+
+      #
+      # Lagging indicators
+      #
+
+      # Simple Moving Average
+      def self.sma data, variables
+        periods = get_variables(variables)
+        usable_data = Array.new
+        usable_data = get_data(data, periods, :adj_close)
+
+        # Just the calculation of SMA by the formula.
+      	sma = []
+    		usable_data.each_with_index do |value, index|
+    			from = index-periods+1
+    			if from >= 0
+    				sum = usable_data[from..index].sum
+    				sma[index] = (sum/periods.to_f)
+    			else
+    				sma[index] = nil
+    			end
+    		end
+    		return sma
+      end
+
+      #
+      # Exponential Moving Average
+
+      # Multiplier: (2 / (Time periods + 1) ) = (2 / (10 + 1) ) = 0.1818 (18.18%)
+      # EMA: {Close - EMA(previous day)} x multiplier + EMA(previous day). 
+      def self.ema data, variables
+        periods = get_variables(variables)
+        usable_data = Array.new
+        usable_data = get_data(data, periods, :adj_close)
+
+        ema = []
+        k = 2/(periods+1).to_f
+        usable_data.each_with_index do |value, index|
+          from = index+1-periods
+          if from == 0
+            ema[index] = sma(usable_data[from..index], periods).last
+            # puts ma
+          elsif from > 0
+            ema[index] = ((usable_data[index] - ema[index-1]) * k + ema[index-1])
+          else
+            ema[index] = nil
+          end
+        end
+        return ema
+      end
+
+      #
+      # Bollinger Bands :type => :bb, :variables => 20, 2)
+
+      # Middle Band = 20-day simple moving average (SMA)
+      # Upper Band = 20-day SMA + (20-day standard deviation of price x 2) 
+      # Lower Band = 20-day SMA - (20-day standard deviation of price x 2)
+      def self.bb data, variables
+        periods = get_variables(variables)
+        default_multiplier = 2
+        multiplier = get_variables(variables, 1, default_multiplier)
+
+        usable_data = Array.new
+        usable_data = get_data(data, periods, :adj_close)
+        bb = []
+        usable_data.each_with_index do |value, index|
+          from = index-periods+1
+          if from >= 0
+            middle_band = sma(usable_data[from..index], periods).last
+            upper_band = middle_band + (usable_data[from..index].standard_deviation * multiplier)
+            lower_band = middle_band - (usable_data[from..index].standard_deviation * multiplier)
+            # output is [middle, upper, lower]
+            bb[index] = [middle_band, upper_band, lower_band]
+          else
+            bb[index] = nil
+          end
+        end
+        return bb
+      end
+
+      #
+      # Moving Average Convergence Divergence
+
+      # MACD Line: (12-day EMA - 26-day EMA) 
+      # Signal Line: 9-day EMA of MACD Line
+      # MACD Histogram: MACD Line - Signal Line
+      # Default MACD(12, 26, 9)
+      def self.macd data, variables
+        faster_periods = get_variables(variables, 0, 12)
+        slower_periods = get_variables(variables, 1, 26)
+        signal_periods = get_variables(variables, 2, 9)
+        @variables = [faster_periods, slower_periods, signal_periods]
+        # puts "faster=#{faster_periods}, slower=#{slower_periods}, signal=#{signal_periods}"
+
+        usable_data = Array.new
+        usable_data = get_data(data, slower_periods+signal_periods-1, :adj_close)
+        macd = []
+        macd_line = []
+
+        usable_data.each_with_index do |value, index|
+          if index+1 >= slower_periods
+            # Calibrate me! Not sure why it doesn't accept from or from_faster.
+            faster_ema = ema(usable_data[0..index], faster_periods).last
+            slower_ema = ema(usable_data[0..index], slower_periods).last
+            macd_line[index] = faster_ema - slower_ema
+            if index+1 >= slower_periods + signal_periods
+              # I'm pretty sure this is right.
+              signal_line = ema(macd_line[(-signal_periods)..index], signal_periods).last 
+              # Output is [MACD, Signal, MACD Hist]
+              macd_histogram = macd_line[index] - signal_line
+              macd[index] = [macd_line[index], signal_line, macd_histogram]
+            end
+          else
+            macd_line[index] = nil
+            macd[index] = nil
+          end
+        end
+        return macd
+      end
+
+      #
+      # Relative Strength Index
+
+      #               100
+      # RSI = 100 - --------
+      #              1 + RS
+      # RS = Average Gain / Average Loss
+      # First Average Gain = Sum of Gains over the past 14 periods / 14
+      # First Average Loss = Sum of Losses over the past 14 periods / 14
+      # Average Gain = [(previous Average Gain) x 13 + current Gain] / 14.
+      # Average Loss = [(previous Average Loss) x 13 + current Loss] / 14.
+      def self.rsi data, variables
+        periods = get_variables(variables)
+        usable_data = Array.new
+        usable_data = get_data(data, periods, :adj_close)
+
+        values = []
+        rsi = []
+        rs = []
+        average_gain = 0.0
+        average_loss = 0.0
+        usable_data.each_with_index do |value, index|
+          values[index] = value
+          if index >= periods
+            if index == periods
+              average_gain = gain(values) / periods
+              average_loss = loss(values) / periods
+            else
+              difference = value - values[index-1]
+              if difference >= 0
+                current_gain = difference
+                current_loss = 0
+              else
+                current_gain = 0
+                current_loss = difference.abs
+              end
+              average_gain = (average_gain * (periods-1) + current_gain) / periods
+              average_loss = (average_loss * (periods-1) + current_loss) / periods
+            end
+            rs[index] = average_gain / average_loss
+            rsi[index] = 100 - 100/(1+rs[index])
+            if average_gain == 0
+              rsi[index] = 0
+            elsif average_loss == 0
+              rsi[index] = 100
+            end
+          else
+            rs[index] = nil
+            rsi[index] = nil
+          end
+        end
+        return rsi
+      end
+
+
+      #
+      # Helper methods for RSI
+      def self.gain data
+        sum = 0.0
+        first_value = nil
+        data.each do |value|
+          if first_value == nil
+            first_value = value
+          else
+            if value > first_value
+              sum += value - first_value
+            end
+            first_value = value
+          end
+        end
+        return sum
+      end
+
+      def self.loss data
+        sum = 0.0
+        first_value = nil
+        data.each do |value|
+          if first_value == nil
+            first_value = value
+          else
+            if value < first_value
+              sum += first_value - value
+            end
+            first_value = value
+          end
+        end
+        return sum
+      end
+
+	end
+end
+
+#
+# Extra methods for mathematical calculations.
+module Enumerable
+
+  def sum
+    return self.inject(0){|accum, i| accum + i }
+  end
+
+  def mean
+    return self.sum / self.length.to_f
+  end
+
+  def sample_variance
+    m = self.mean
+    sum = self.inject(0){|accum, i| accum + (i - m) ** 2 }
+    return sum / (self.length - 1).to_f
+  end
+
+  def standard_deviation
+    return Math.sqrt(self.sample_variance)
+  end
+
+end

data/lib/indicators/parser.rb

@@ -0,0 +1,27 @@
+module Indicators
+
+	# Class to parse a securities gem return hash.
+	class Parser
+
+		# Error handling.
+		class ParserException < StandardError
+		end
+
+		def self.parse_data parameters
+			
+			usable_data = Hash.new
+			transposed_hash = Hash.new
+			# Such a hacky way to transpose an array.
+			# FIXME: Now v.to_f converts date to float, it shouldn't.
+			parameters.reverse.inject({}){|a, h| 
+			  h.each_pair{|k,v| (a[k] ||= []) << v.to_f}
+			  transposed_hash = a
+			}
+		 	usable_data = transposed_hash
+		 	# usable data is are {:close => [1, 2, 3], :open => []}
+
+			return usable_data
+		end
+
+	end
+end

data/lib/indicators/version.rb

@@ -0,0 +1,3 @@
+module Indicators
+  VERSION = "0.0.1"
+end

data/lib/indicators.rb

@@ -0,0 +1,8 @@
+require "indicators/version"
+require "securities"
+require "indicators/data.rb"
+require "indicators/parser.rb"
+require "indicators/main.rb"
+
+module Indicators
+end

data/spec/data_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Data do
+
+	context "should raise an exception if" do
+	  it "nil or empty" do
+	  	expect { Indicators::Data.new(nil) }.to raise_error
+	  	expect { Indicators::Data.new('') }.to raise_error
+	  end
+	  it "not an array or hash" do
+	  	expect { Indicators::Data.new('some string') }.to raise_error
+	  end
+	  it "contains dividends hash from securities gem" do
+	  	expect { Indicators::Data.new(Securities::Stock.new(["aapl"]).history(:start_date => '2012-08-01', :end_date => '2012-08-10', :periods => :dividends).results) }.to raise_error
+		end
+	end
+
+	context "should not raise an exception if" do
+		it "is an array" do
+			expect { Indicators::Data.new([1, 2, 3]) }.not_to raise_error
+		end
+		it "is a hash" do
+			expect { Indicators::Data.new(Securities::Stock.new(["aapl"]).history(:start_date => '2012-08-01', :end_date => '2012-08-03', :periods => :daily).results) }.not_to raise_error
+		end
+
+	end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'indicators'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: indicators
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nedomas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: securities
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: A gem for calculating technical analysis indicators.
+email:
+- domas.bitvinskas@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- indicators.gemspec
+- lib/indicators.rb
+- lib/indicators/data.rb
+- lib/indicators/main.rb
+- lib/indicators/parser.rb
+- lib/indicators/version.rb
+- spec/data_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Nedomas/indicators
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3875007528278561270
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3875007528278561270
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A gem for calculating technical analysis indicators.
+test_files:
+- spec/data_spec.rb
+- spec/spec_helper.rb