indicators 0.1.0 → 1.0.0

data/README.md

@@ -28,7 +28,7 @@ Or install it yourself as:
 
 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]
+	i.e. my_data.calc(:type => :sma, :params => 2).output => [nil, 1.5, 2.5, 3.5, 4.5]
 
 # Securities gem hash
 
@@ -38,28 +38,38 @@ Then it returns a hash so it can be quite powerful at calculating multiple stock
 
 	{"aapl"=>[nil, 675.24, 674.0600000000001], "yhoo"=>[nil, 14.785, 14.821666666666667]}
 
+## Output
+
+.calc returns an object with such accessor methods
+
+	@abbr - indicator abbreviation (usually used when displaying information).
+	@params - given or defaulted parameters.
+	@output - indicator calculation result.
+
+	i.e. @abbr="SMA", @params=2, @output=[nil, 1.5, 2.5, 3.5, 4.5]
+
 ## Supported Indicators
 
 # Simple Moving Average => :sma
 
-	my_data.calc(:type => :sma, :variables => 5)
+	my_data.calc(:type => :sma, :params => 5)
 
 #	Exponental Moving Average => :ema
 
-	my_data.calc(:type => :ema, :variables => 5)
+	my_data.calc(:type => :ema, :params => 5)
 
 # Bollinger Bands => :bb
 
-	my_data.calc(:type => :bb, :variables => [15, 3])
+	my_data.calc(:type => :bb, :params => [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]]} 
+	i.e. my_data.calc(:type => :bb, :params => 3) => {"aapl"=>[nil, nil, [674.65, 676.8752190903368, 672.4247809096631]]} 
 
 # Moving Average Convergence Divergence => :macd
 
-	my_data.calc(:type => :macd, :variables => [12, 26, 9])
+	my_data.calc(:type => :macd, :params => [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.
 
@@ -67,13 +77,13 @@ Variables have to be specified as an array [faster periods, slower periods, sign
 
 # Relative Strength Index => :rsi
 
-	my_data.calc(:type => :rsi, :variables => 14)
+	my_data.calc(:type => :rsi, :params => 14)
 
 The more data it has, the more accurate RSI is.
 
 # Full Stochastic Oscillator => :sto
 
-	my_data.calc(:type => :sto, :variables => [14, 3, 5])
+	my_data.calc(:type => :sto, :params => [14, 3, 5])
 
 Variables have to be specified as an array [lookback period, the number of periods to slow %K, the number of periods for the %D moving average] => [%K1, %K2, %D].
 
@@ -81,9 +91,7 @@ Variables have to be specified as an array [lookback period, the number of perio
 
 ## To Do
 
-* Make defaults mechanism more versatile.
 * Write specs.
-* More validations.
 * A strategy backtesting tool.
 
 # Indicators:

data/lib/indicators.rb

@@ -4,5 +4,17 @@ require "indicators/data.rb"
 require "indicators/parser.rb"
 require "indicators/main.rb"
 
+require "indicators/calculations/helper.rb"
+
+# Lagging Indicators
+require "indicators/calculations/sma.rb"
+require "indicators/calculations/ema.rb"
+require "indicators/calculations/bb.rb"
+require "indicators/calculations/macd.rb"
+
+# Leading Indicators
+require "indicators/calculations/rsi.rb"
+require "indicators/calculations/sto.rb"
+
 module Indicators
 end

data/lib/indicators/calculations/bb.rb

@@ -0,0 +1,33 @@
+module Indicators
+  #
+  # Bollinger Bands
+  class Bb     
+
+    # 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.calculate data, parameters
+      periods = parameters[0] 
+      multiplier = parameters[1]
+      output = Array.new
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, periods)
+
+      adj_closes.each_with_index do |adj_close, index|
+        start = index+1-periods
+        if index+1 >= periods
+          middle_band = Indicators::Sma.calculate(adj_closes[start..index], periods).last
+          upper_band = middle_band + (adj_closes[start..index].standard_deviation * multiplier)
+          lower_band = middle_band - (adj_closes[start..index].standard_deviation * multiplier)
+          # Output for each point is [middle, upper, lower].
+          output[index] = [middle_band, upper_band, lower_band]
+        else
+          output[index] = nil
+        end
+      end
+
+      return output
+      
+    end
+
+  end
+end

data/lib/indicators/calculations/ema.rb

@@ -0,0 +1,31 @@
+module Indicators
+  #
+  # Exponential Moving Average
+  class Ema
+
+    # Multiplier: (2 / (Time periods + 1) ) = (2 / (10 + 1) ) = 0.1818 (18.18%)
+    # EMA: {Close - EMA(previous day)} x multiplier + EMA(previous day). 
+    def self.calculate data, parameters
+      periods = parameters
+      output = Array.new
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, periods)
+
+      k = 2.0/(periods+1)
+      adj_closes.each_with_index do |adj_close, index|
+        start = index+1-periods
+        if start == 0
+          output[index] = Indicators::Sma.calculate(adj_closes[start..index], periods).last
+        elsif start > 0
+          output[index] = ((adj_close - output[index-1]) * k + output[index-1])
+        else
+          output[index] = nil
+        end
+      end
+      
+      return output
+
+    end
+
+  end
+
+end

data/lib/indicators/calculations/helper.rb

@@ -0,0 +1,91 @@
+module Indicators
+  # Main helper methods
+  class Helper
+
+    # Error handling.
+    class HelperException < StandardError
+    end
+
+    def self.validate_data data, column, parameters
+      # If this is a hash, choose which column of values to use for calculations.
+      if data.is_a?(Hash)
+        valid_data = data[column]
+      else
+        valid_data = data
+      end
+
+      # Make output more friendly
+      # if parameters.is_a?(Array)
+      #   parameters_array = parameters
+      #   parameters = parameters.sum
+      # end
+
+      if valid_data.length < parameters
+        raise HelperException, "Data point length (#{valid_data.length}) must be greater than or equal to the required indicator periods (#{parameters})."
+      end
+      return valid_data
+    end
+
+    # Indicators::Helper.get_parameters([12, 1, 1], 0, 15)
+    def self.get_parameters parameters, i=0, default=0
+
+      if parameters.is_a?(Integer) || parameters.is_a?(NilClass)
+
+        # Set all other to default if only one integer is given instead of an array.
+        return default if i != 0
+
+        # Check if no parameters are specified at all, if so => set to default.
+        # Parameters 15, 0, 0 are equal to 15 or 15, nil, nil.
+        if parameters == nil || parameters == 0
+          if default != 0
+            return default
+          else
+            raise HelperException, "There were no parameters specified and there is no default for it."
+          end
+        else
+          return parameters
+        end
+      elsif parameters.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.
+        parameters = parameters.map(&:to_i)
+        if parameters[i] == nil || parameters[i] == 0
+          if default != 0
+            return default
+          else
+            raise HelperException, "There were no parameters specified and there is no default for it."
+          end
+        else
+          return parameters[i]
+        end
+      else
+        raise HelperException, "Parameters have to be a integer, an array or nil."
+      end
+
+    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/calculations/macd.rb

@@ -0,0 +1,45 @@
+module Indicators
+  #
+  # Moving Average Convergence Divergence
+  class Macd
+
+    # 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.calculate data, parameters
+      faster_periods = parameters[0]
+      slower_periods = parameters[1]
+      signal_periods = parameters[2]
+      output = Array.new
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, slower_periods+signal_periods-1)
+      # puts "faster=#{faster_periods}, slower=#{slower_periods}, signal=#{signal_periods}"
+
+      macd_line = []
+
+      adj_closes.each_with_index do |adj_close, index|
+        if index+1 >= slower_periods
+          # Calibrate me! Not sure why it doesn't accept from or from_faster.
+          faster_ema = Indicators::Ema.calculate(adj_closes[0..index], faster_periods).last
+          slower_ema = Indicators::Ema.calculate(adj_closes[0..index], slower_periods).last
+          macd_line[index] = faster_ema - slower_ema
+          if index+1 >= slower_periods+signal_periods
+            signal_line = Indicators::Ema.calculate(macd_line[(-signal_periods)..index], signal_periods).last 
+            # Output is [MACD, Signal, MACD Hist]
+            macd_histogram = macd_line[index] - signal_line
+            output[index] = [macd_line[index], signal_line, macd_histogram]
+          else 
+            output[index] = [macd_line[index], nil, nil]
+          end
+        else
+          macd_line[index] = nil
+          output[index] = nil
+        end
+      end
+
+      return output
+
+    end
+
+  end
+end

data/lib/indicators/calculations/rsi.rb

@@ -0,0 +1,81 @@
+ module Indicators
+  #
+  # Relative Strength Index
+  class Rsi
+
+    #               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.calculate data, parameters
+      periods = parameters
+      output = Array.new
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, periods)
+
+      rs = Array.new
+      average_gain = 0.0
+      average_loss = 0.0
+      adj_closes.each_with_index do |adj_close, index|
+        if index >= periods
+          if index == periods
+            average_gain = gain_or_loss(adj_closes[0..index], :gain) / periods
+            average_loss = gain_or_loss(adj_closes[0..index], :loss) / periods
+          else
+            difference = adj_close - adj_closes[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
+          output[index] = 100 - 100/(1+rs[index])
+          if average_gain == 0
+            output[index] = 0
+          elsif average_loss == 0
+            output[index] = 100
+          end
+        else
+          rs[index] = nil
+          output[index] = nil
+        end
+      end
+
+      return output
+
+    end
+
+    #
+    # Helper methods for RSI
+    def self.gain_or_loss data, type
+      sum = 0.0
+      first_value = nil
+      data.each do |value|
+        if first_value == nil
+          first_value = value
+        else
+          if type == :gain
+            if value > first_value
+              sum += value - first_value
+            end
+          elsif type == :loss
+            if value < first_value
+              sum += first_value - value
+            end
+          end
+          first_value = value
+        end
+      end
+      return sum
+    end
+
+  end
+end

data/lib/indicators/calculations/sma.rb

@@ -0,0 +1,27 @@
+module Indicators
+  #
+  # Simple Moving Average
+  class Sma
+
+    # SMA: (sum of closing prices for x period)/x
+    def self.calculate data, parameters
+      periods = parameters
+      output = Array.new
+      # Returns an array from the requested column and checks if there is enought data points.
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, periods)
+
+      adj_closes.each_with_index do |adj_close, index|
+        start = index+1-periods
+      	if index+1 >= periods
+      		adj_closes_sum = adj_closes[start..index].sum
+      		output[index] = (adj_closes_sum/periods.to_f)
+      	else
+      		output[index] = nil
+      	end
+      end
+      return output
+      
+    end
+
+  end
+end

data/lib/indicators/calculations/sto.rb

@@ -0,0 +1,54 @@
+ module Indicators
+  #
+  # Full Stochastic Oscillator
+  class Sto
+
+    # %K = (Current Close - Lowest Low)/(Highest High - Lowest Low) * 100
+    # %D = 3-day SMA of %K
+    # Lowest Low = lowest low for the look-back period
+    # Highest High = highest high for the look-back period
+    # %K is multiplied by 100 to move the decimal point two places
+    #
+    # Full %K = Fast %K smoothed with X-period SMA
+    # Full %D = X-period SMA of Full %K
+    #
+    # Input 14, 3, 5
+    # Returns [full %K, full %D]
+    def self.calculate data, parameters
+      k1_periods = parameters[0]
+      k2_periods = parameters[1]
+      d_periods = parameters[2]
+      output = Array.new
+      adj_closes = Indicators::Helper.validate_data(data, :adj_close, k1_periods)
+      highs = Indicators::Helper.validate_data(data, :high, k1_periods)
+      lows = Indicators::Helper.validate_data(data, :low, k1_periods)
+
+      k1 = []
+      k2 = []
+      d = []
+      adj_closes.each_with_index do |adj_close, index|
+        start = index+1-k1_periods
+        if index+1 >= k1_periods
+          k1[index] = (adj_close - lows[start..index].min) / (highs[start..index].max - lows[start..index].min) * 100
+          if index+2 >= k1_periods + k2_periods
+            k2[index] = Indicators::Sma.calculate(k1[(k1_periods-1)..index], k2_periods).last
+          else 
+            k2[index] = nil
+          end
+          if index+3 >= k1_periods + k2_periods + d_periods
+            d[index] = Indicators::Sma.calculate(k2[(k1_periods + k2_periods - 2)..index], d_periods).last
+          else
+            d[index] = nil
+          end
+        else
+          k1[index] = nil
+        end
+        output[index] = [k1[index], k2[index], d[index]]
+      end
+
+      return output
+
+    end
+
+  end
+end

data/lib/indicators/data.rb

@@ -27,7 +27,7 @@ module Indicators
 		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)'
+				raise DataException, 'Given parameters have to be a hash. FORMAT: .calc(:type => :ema, :params => 12)'
 			end
 
 			# If not specified, set default :type to :sma.
@@ -35,7 +35,7 @@ module Indicators
 
 			# Check if there is such indicator type supported.
 			case
-				when INDICATORS.include?(parameters[:type]) then @results = Indicators::Main.calculate(@data, parameters)
+				when INDICATORS.include?(parameters[:type]) then @results = Indicators::Main.new(@data, parameters)
 			else 
 				raise DataException, "Invalid indicator type specified (#{parameters[:type]})."
 			end

data/lib/indicators/main.rb

@@ -1,358 +1,68 @@
 module Indicators
-  #
-  # Moving averages
+
 	class Main
 
+    attr_reader :output, :abbr, :params
     # Error handling.
     class MainException < StandardError
     end
 
-		def self.calculate data, parameters
+		def initialize data, parameters
+      type = parameters[:type]
+      all_params = parameters[:params]
+      @abbr = type.to_s.upcase
+      if type == :sma
+        @params = Indicators::Helper.get_parameters(all_params, 0, 20)
+      elsif type == :ema
+        @params = Indicators::Helper.get_parameters(all_params, 0, 20)
+      elsif type == :bb
+        @params = Array.new
+        @params[0] = Indicators::Helper.get_parameters(all_params, 0, 20)
+        @params[1] = Indicators::Helper.get_parameters(all_params, 1, 2)
+      elsif type == :macd
+        @params = Array.new
+        @params[0] = Indicators::Helper.get_parameters(all_params, 0, 12)
+        @params[1] = Indicators::Helper.get_parameters(all_params, 1, 26)
+        @params[2] = Indicators::Helper.get_parameters(all_params, 2, 9)
+      elsif type == :rsi
+        @params = Indicators::Helper.get_parameters(all_params, 0, 14)
+      elsif type == :sto
+        @params = Array.new
+        @params[0] = Indicators::Helper.get_parameters(all_params, 0, 14)
+        @params[1] = Indicators::Helper.get_parameters(all_params, 1, 3)
+        @params[2] = Indicators::Helper.get_parameters(all_params, 2, 3)
+      end
+
 			if data.is_a?(Hash)
-        results = Hash.new
+        @output = 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] = []
+            @output[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])
-                                when :sto then sto(Indicators::Parser.parse_data(stock_data), parameters[:variables])
+            @output[symbol] = case type
+                                when :sma then Indicators::Sma.calculate(Indicators::Parser.parse_data(stock_data), @params)
+                                when :ema then Indicators::Ema.calculate(Indicators::Parser.parse_data(stock_data), @params)
+                                when :bb then Indicators::Bb.calculate(Indicators::Parser.parse_data(stock_data), @params)
+                                when :macd then Indicators::Macd.calculate(Indicators::Parser.parse_data(stock_data), @params)
+                                when :rsi then Indicators::Rsi.calculate(Indicators::Parser.parse_data(stock_data), @params)
+                                when :sto then Indicators::Sto.calculate(Indicators::Parser.parse_data(stock_data), @params)
                               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])
-                    when :sto then raise MainException, "You cannot calculate Stochastic Oscillator on closing prices. Use Securities hash instead."
+				@output = case type
+				            when :sma then Indicators::Sma.calculate(data, @params)
+                    when :ema then Indicators::Ema.calculate(data, @params)
+                    when :bb then Indicators::Bb.calculate(data, @params)
+                    when :macd then Indicators::Macd.calculate(data, @params)
+                    when :rsi then Indicators::Rsi.calculate(data, @params)
+                    when :sto then raise MainException, "You cannot calculate Stochastic Oscillator on array. Highs and lows are needed. Feel free Securities gem hash instead."
 				          end
 			end
-			return results
+      return @output
     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
-
-      #
-      # Full Stochastic Oscillator
-
-      # %K = (Current Close - Lowest Low)/(Highest High - Lowest Low) * 100
-      # %D = 3-day SMA of %K
-      # Lowest Low = lowest low for the look-back period
-      # Highest High = highest high for the look-back period
-      # %K is multiplied by 100 to move the decimal point two places
-      #
-      # Full %K = Fast %K smoothed with X-period SMA
-      # Full %D = X-period SMA of Full %K
-      #
-      # Input 14, 3, 5
-      # Returns [full %K, full %D]
-      def self.sto data, variables
-        k1_periods = get_variables(variables, 0, 14)
-        k2_periods = get_variables(variables, 1, 3)
-        d_periods = get_variables(variables, 2, 1)
-        high_data = Array.new
-        low_data = Array.new
-        adj_close_data = Array.new
-        high_data = get_data(data, k1_periods, :high)
-        low_data = get_data(data, k1_periods, :low)
-        adj_close_data = get_data(data, k1_periods, :adj_close)
-
-        k1 = []
-        k2 = []
-        d = []
-        sto = []
-        adj_close_data.each_with_index do |adj_close, index|
-          from = index-k1_periods+1
-          if index+1 >= k1_periods
-            k1[index] = (adj_close - low_data[from..index].min) / (high_data[from..index].max - low_data[from..index].min) * 100
-            if index+2 >= k1_periods + k2_periods
-              k2[index] = sma(k1[(k1_periods-1)..index], k2_periods).last
-            else 
-              k2[index] = nil
-            end
-            if index+3 >= k1_periods + k2_periods + d_periods
-              d[index] = sma(k2[(k1_periods + k2_periods - 2)..index], d_periods).last
-            else
-              d[index] = nil
-            end
-          else
-            k1[index] = nil
-          end
-          sto[index] = [k1[index], k2[index], d[index]]
-        end
-        return sto
-      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/version.rb

@@ -1,3 +1,3 @@
 module Indicators
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indicators
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-02 00:00:00.000000000 Z
+date: 2012-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -75,6 +75,13 @@ files:
 - Rakefile
 - indicators.gemspec
 - lib/indicators.rb
+- lib/indicators/calculations/bb.rb
+- lib/indicators/calculations/ema.rb
+- lib/indicators/calculations/helper.rb
+- lib/indicators/calculations/macd.rb
+- lib/indicators/calculations/rsi.rb
+- lib/indicators/calculations/sma.rb
+- lib/indicators/calculations/sto.rb
 - lib/indicators/data.rb
 - lib/indicators/main.rb
 - lib/indicators/parser.rb
@@ -95,7 +102,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1434689323242091745
+      hash: 856502728936260822
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -104,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1434689323242091745
+      hash: 856502728936260822
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24