technical-analysis 0.1.0

data/lib/technical_analysis/indicators/indicator.rb

@@ -0,0 +1,138 @@
+module TechnicalAnalysis
+  class Indicator
+
+    CALCULATIONS = [
+      :indicator_name,
+      :indicator_symbol,
+      :min_data_size,
+      :technicals,
+      :valid_options,
+      :validate_options,
+    ].freeze
+
+    private_constant :CALCULATIONS
+
+    # Returns an array of TechnicalAnalysis modules
+    #
+    # @return [Array] A list of TechnicalAnalysis::Class
+    def self.roster
+      [
+        TechnicalAnalysis::Adi,
+        TechnicalAnalysis::Adtv,
+        TechnicalAnalysis::Adx,
+        TechnicalAnalysis::Ao,
+        TechnicalAnalysis::Atr,
+        TechnicalAnalysis::Bb,
+        TechnicalAnalysis::Cci,
+        TechnicalAnalysis::Cmf,
+        TechnicalAnalysis::Cr,
+        TechnicalAnalysis::Dc,
+        TechnicalAnalysis::Dlr,
+        TechnicalAnalysis::Dpo,
+        TechnicalAnalysis::Dr,
+        TechnicalAnalysis::Eom,
+        TechnicalAnalysis::Fi,
+        TechnicalAnalysis::Ichimoku,
+        TechnicalAnalysis::Kc,
+        TechnicalAnalysis::Kst,
+        TechnicalAnalysis::Macd,
+        TechnicalAnalysis::Mfi,
+        TechnicalAnalysis::Mi,
+        TechnicalAnalysis::Nvi,
+        TechnicalAnalysis::Obv,
+        TechnicalAnalysis::ObvMean,
+        TechnicalAnalysis::Rsi,
+        TechnicalAnalysis::Sma,
+        TechnicalAnalysis::Sr,
+        TechnicalAnalysis::Trix,
+        TechnicalAnalysis::Tsi,
+        TechnicalAnalysis::Uo,
+        TechnicalAnalysis::Vi,
+        TechnicalAnalysis::Vpt,
+        TechnicalAnalysis::Wr,
+      ]
+    end
+
+    # Finds the applicable indicator and returns an instance
+    #
+    # @param indicator_symbol [String] Downcased string of the indicator symbol
+    #
+    # @return TechnicalAnalysis::ClassName
+    def self.find(indicator_symbol)
+      roster.each do |indicator|
+        return indicator if indicator.indicator_symbol == indicator_symbol
+      end
+
+      nil
+    end
+
+    # Find the applicable indicator and looks up the value
+    #
+    # @param indicator_symbol [String] Downcased string of the indicator symbol
+    # @param data [Array] Array of hashes of price data to perform calcualtion on
+    # @param calculation [Symbol] The calculation to be performed on the requested indicator and params
+    # @param options [Hash] A hash containing options for the requested calculation
+    #
+    # @return Returns the requested calculation
+    def self.calculate(indicator_symbol, data, calculation, options={})
+      return nil unless CALCULATIONS.include? calculation
+
+      indicator = find(indicator_symbol)
+      raise "Indicator not found!" if indicator.nil?
+
+      case calculation
+      when :indicator_name; indicator.indicator_name
+      when :indicator_symbol; indicator.indicator_symbol
+      when :technicals; indicator.calculate(data, options)
+      when :min_data_size; indicator.min_data_size(options)
+      when :valid_options; indicator.valid_options
+      when :validate_options; indicator.validate_options(options)
+      else nil
+      end
+    end
+
+    # Calculates the minimum number of observations needed to calculate the technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator
+    #
+    # @return [Integer] Returns the minimum number of observations needed to calculate the technical
+    #    indicator based on the options provided
+    def self.min_data_size(indicator_symbol, options)
+      raise "#{self.name} did not implement min_data_size"
+      nil
+    end
+
+    # Validates the provided options for this technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator to be validated
+    #
+    # @return [Boolean] Returns true if options are valid or raises a ValidationError if they're not
+    def self.validate_options(options)
+      raise "#{self.name} did not implement validate_options"
+      false
+    end
+
+    # Returns an array of valid keys for options for this technical indicator
+    #
+    # @return [Array] An array of keys as symbols for valid options for this technical indicator
+    def self.valid_options
+      raise "#{self.name} did not implement valid_options"
+      []
+    end
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      raise "#{self.name} did not implement indicator_symbol"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      raise "#{self.name} did not implement indicator_name"
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/kc.rb

@@ -0,0 +1,124 @@
+module TechnicalAnalysis
+  # Keltner Channel
+  class Kc < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "kc"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Keltner Channel"
+    end
+
+    # Returns an array of valid keys for options for this technical indicator
+    #
+    # @return [Array] An array of keys as symbols for valid options for this technical indicator
+    def self.valid_options
+      %i(period)
+    end
+
+    # Validates the provided options for this technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator to be validated
+    #
+    # @return [Boolean] Returns true if options are valid or raises a ValidationError if they're not
+    def self.validate_options(options)
+      Validation.validate_options(options, valid_options)
+    end
+
+    # Calculates the minimum number of observations needed to calculate the technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator
+    #
+    # @return [Integer] Returns the minimum number of observations needed to calculate the technical
+    #    indicator based on the options provided
+    def self.min_data_size(period: 10)
+      period.to_i
+    end
+
+    # Calculates the keltner channel (KC) for the data over the given period
+    # https://en.wikipedia.org/wiki/Keltner_channel
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close)
+    # @param period [Integer] The given period to calculate the KC
+    #
+    # @return [Array<KcValue>] An array of KcValue instances
+    def self.calculate(data, period: 10)
+      period = period.to_i
+      Validation.validate_numeric_data(data, :high, :low, :close)
+      Validation.validate_length(data, min_data_size(period: period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      output = []
+      period_values = []
+
+      data.each do |v|
+        tp = StockCalculation.typical_price(v)
+        tr = v[:high] - v[:low]
+        period_values << { typical_price: tp, trading_range: tr }
+
+        if period_values.size == period
+          mb = ArrayHelper.average(period_values.map { |pv| pv[:typical_price] })
+
+          trading_range_average = ArrayHelper.average(period_values.map { |pv| pv[:trading_range] })
+          ub = mb + trading_range_average
+          lb = mb - trading_range_average
+
+          output << KcValue.new(
+            date_time: v[:date_time],
+            lower_band: lb,
+            middle_band: mb,
+            upper_band: ub
+          )
+
+          period_values.shift
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class KcValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the lower_band calculation value
+    attr_accessor :lower_band
+
+    # @return [Float] the middle_band calculation value
+    attr_accessor :middle_band
+
+    # @return [Float] the upper_band calculation value
+    attr_accessor :upper_band
+
+    def initialize(date_time: nil, lower_band: nil, middle_band: nil, upper_band: nil)
+      @date_time = date_time
+      @lower_band = lower_band
+      @middle_band = middle_band
+      @upper_band = upper_band
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      {
+        date_time: @date_time,
+        lower_band: @lower_band,
+        middle_band: @middle_band,
+        upper_band: @upper_band
+      }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/kst.rb

@@ -0,0 +1,132 @@
+module TechnicalAnalysis
+  # Know Sure Thing
+  class Kst < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "kst"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Know Sure Thing"
+    end
+
+    # Returns an array of valid keys for options for this technical indicator
+    #
+    # @return [Array] An array of keys as symbols for valid options for this technical indicator
+    def self.valid_options
+      %i(period roc1 roc2 roc3 roc4 sma1 sma2 sma3 sma4 price_key)
+    end
+
+    # Validates the provided options for this technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator to be validated
+    #
+    # @return [Boolean] Returns true if options are valid or raises a ValidationError if they're not
+    def self.validate_options(options)
+      Validation.validate_options(options, valid_options)
+    end
+
+    # Calculates the minimum number of observations needed to calculate the technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator
+    #
+    # @return [Integer] Returns the minimum number of observations needed to calculate the technical
+    #    indicator based on the options provided
+    def self.min_data_size(roc4: 30, sma4: 15, **params)
+      roc4.to_i + sma4.to_i - 1
+    end
+
+    # Calculates the know sure thing (KST) for the data over the given period
+    # https://en.wikipedia.org/wiki/KST_oscillator
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param roc1 [Integer] The given period to calculate the rate-of-change for RCMA1
+    # @param roc2 [Integer] The given period to calculate the rate-of-change for RCMA2
+    # @param roc3 [Integer] The given period to calculate the rate-of-change for RCMA3
+    # @param roc4 [Integer] The given period to calculate the rate-of-change for RCMA4
+    # @param sma1 [Integer] The given period to calculate the SMA of the rate-of-change for RCMA1
+    # @param sma2 [Integer] The given period to calculate the SMA of the rate-of-change for RCMA2
+    # @param sma3 [Integer] The given period to calculate the SMA of the rate-of-change for RCMA3
+    # @param sma4 [Integer] The given period to calculate the SMA of the rate-of-change for RCMA4
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<KstValue>] An array of KstValue instances
+    def self.calculate(data, roc1: 10, roc2: 15, roc3: 20, roc4: 30, sma1: 10, sma2: 10, sma3: 10, sma4: 15, price_key: :value)
+      roc1 = roc1.to_i
+      roc2 = roc2.to_i
+      roc3 = roc3.to_i
+      roc4 = roc4.to_i
+      sma1 = sma1.to_i
+      sma2 = sma2.to_i
+      sma3 = sma3.to_i
+      sma4 = sma4.to_i
+      price_key = price_key.to_sym
+      Validation.validate_numeric_data(data, price_key)
+      Validation.validate_length(data, min_data_size(roc4: roc4, sma4: sma4))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      index = roc4 + sma4 - 2
+      output = []
+
+      while index < data.size
+        date_time = data[index][:date_time] 
+        rcma1 = calculate_rcma(data, index, price_key, roc1, sma1)
+        rcma2 = calculate_rcma(data, index, price_key, roc2, sma2)
+        rcma3 = calculate_rcma(data, index, price_key, roc3, sma3)
+        rcma4 = calculate_rcma(data, index, price_key, roc4, sma4)
+
+        kst = (1 * rcma1) + (2 * rcma2) + (3 * rcma3) + (4 * rcma4)
+
+        output << KstValue.new(date_time: date_time, kst: kst)
+
+        index += 1
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+    private_class_method def self.calculate_rcma(data, index, price_key, roc, sma)
+      roc_data = []
+      index_range = (index - sma + 1)..index
+
+      index_range.each do |i|
+        last_price = data[i][price_key]
+        starting_price = data[i - roc + 1][price_key]
+
+        roc_data << (last_price - starting_price) / starting_price * 100
+      end
+
+      ArrayHelper.sum(roc_data) / sma.to_f
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class KstValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the kst calculation value
+    attr_accessor :kst
+
+    def initialize(date_time: nil, kst: nil)
+      @date_time = date_time
+      @kst = kst
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, kst: @kst }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/macd.rb

@@ -0,0 +1,144 @@
+module TechnicalAnalysis
+  # Moving Average Convergence Divergence
+  class Macd < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "macd"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Moving Average Convergence Divergence"
+    end
+
+    # Returns an array of valid keys for options for this technical indicator
+    #
+    # @return [Array] An array of keys as symbols for valid options for this technical indicator
+    def self.valid_options
+      %i(fast_period slow_period signal_period price_key)
+    end
+
+    # Validates the provided options for this technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator to be validated
+    #
+    # @return [Boolean] Returns true if options are valid or raises a ValidationError if they're not
+    def self.validate_options(options)
+      Validation.validate_options(options, valid_options)
+    end
+
+    # Calculates the minimum number of observations needed to calculate the technical indicator
+    #
+    # @param options [Hash] The options for the technical indicator
+    #
+    # @return [Integer] Returns the minimum number of observations needed to calculate the technical
+    #    indicator based on the options provided
+    def self.min_data_size(slow_period: 26, signal_period: 9, **params)
+      slow_period.to_i + signal_period.to_i - 1
+    end
+
+    # Calculates the moving average convergence divergence (MACD) for the data over the given period
+    # https://en.wikipedia.org/wiki/MACD
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param fast_period [Integer] The given period to calculate the fast moving EMA for MACD
+    # @param slow_period [Integer] The given period to calculate the slow moving EMA for MACD
+    # @param signal_period [Integer] The given period to calculate the signal line for MACD
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<MacdValue>] An array of MacdValue instances
+    def self.calculate(data, fast_period: 12, slow_period: 26, signal_period: 9, price_key: :value)
+      fast_period = fast_period.to_i
+      slow_period = slow_period.to_i
+      signal_period = signal_period.to_i
+      price_key = price_key.to_sym
+      Validation.validate_numeric_data(data, price_key)
+      Validation.validate_length(data, min_data_size(slow_period: slow_period, signal_period: signal_period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      macd_values = []
+      output = []
+      period_values = []
+      prev_fast_ema = nil
+      prev_signal = nil
+      prev_slow_ema = nil
+
+      data.each do |v|
+        period_values << v[price_key]
+
+        if period_values.size >= fast_period
+          fast_ema = StockCalculation.ema(v[price_key], period_values, fast_period, prev_fast_ema)
+          prev_fast_ema = fast_ema
+
+          if period_values.size == slow_period
+            slow_ema = StockCalculation.ema(v[price_key], period_values, slow_period, prev_slow_ema)
+            prev_slow_ema = slow_ema
+
+            macd = fast_ema - slow_ema
+            macd_values << macd
+            
+            if macd_values.size == signal_period
+              signal = StockCalculation.ema(macd, macd_values, signal_period, prev_signal)
+              prev_signal = signal
+
+              output << MacdValue.new(
+                date_time: v[:date_time],
+                macd_line: macd,
+                signal_line: signal,
+                macd_histogram: macd - signal,
+              )
+
+              macd_values.shift
+            end
+
+            period_values.shift
+          end
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class MacdValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the macd_line calculation value
+    attr_accessor :macd_line
+
+    # @return [Float] the macd_histogram calculation value
+    attr_accessor :macd_histogram
+
+    # @return [Float] the signal_line calculation value
+    attr_accessor :signal_line
+
+    def initialize(date_time: nil, macd_line: nil, macd_histogram: nil, signal_line: nil)
+      @date_time = date_time
+      @macd_line = macd_line
+      @macd_histogram = macd_histogram
+      @signal_line = signal_line
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      {
+        date_time: @date_time,
+        macd_line: @macd_line,
+        macd_histogram: @macd_histogram,
+        signal_line: @signal_line
+      }
+    end
+
+  end
+end