technical-analysis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f408c4203ba656b1aa458266b8ed6ec656f91f2e
+  data.tar.gz: 18c7d6c4465b9ddbf6627508672e3a8f3295a597
+SHA512:
+  metadata.gz: dcb6a96e644cc93c7f48866aa067c6cac7ca7c226cfeb3a71bd4a1789f258dee846b19c774a95560001cff93a8e6c693d4386a3247ea7aebb404beb37121f7bb
+  data.tar.gz: 42e5e7bbfedb0f48a92b5107edfa2fda26c616cdb67bd91984e53fbd47f145fb50323da63268b34722202c71029d75fabfd94dba0136497baf508e874289c877

data/lib/technical-analysis.rb

@@ -0,0 +1,3 @@
+# This allows 'technical_analysis' AND 'technical-analysis" to work for requires
+# Place additional requires in technical_analysis.rb
+require 'technical_analysis'

data/lib/technical_analysis.rb

@@ -0,0 +1,41 @@
+# Helpers
+require 'technical_analysis/helpers/array_helper'
+require 'technical_analysis/helpers/stock_calculation'
+require 'technical_analysis/helpers/validation'
+
+# Indicators
+require 'technical_analysis/indicators/indicator'
+
+require 'technical_analysis/indicators/adi'
+require 'technical_analysis/indicators/adtv'
+require 'technical_analysis/indicators/adx'
+require 'technical_analysis/indicators/ao'
+require 'technical_analysis/indicators/atr'
+require 'technical_analysis/indicators/bb'
+require 'technical_analysis/indicators/cci'
+require 'technical_analysis/indicators/cmf'
+require 'technical_analysis/indicators/cr'
+require 'technical_analysis/indicators/dc'
+require 'technical_analysis/indicators/dlr'
+require 'technical_analysis/indicators/dpo'
+require 'technical_analysis/indicators/dr'
+require 'technical_analysis/indicators/eom'
+require 'technical_analysis/indicators/fi'
+require 'technical_analysis/indicators/ichimoku'
+require 'technical_analysis/indicators/kc'
+require 'technical_analysis/indicators/kst'
+require 'technical_analysis/indicators/macd'
+require 'technical_analysis/indicators/mfi'
+require 'technical_analysis/indicators/mi'
+require 'technical_analysis/indicators/nvi'
+require 'technical_analysis/indicators/obv'
+require 'technical_analysis/indicators/obv_mean'
+require 'technical_analysis/indicators/rsi'
+require 'technical_analysis/indicators/sma'
+require 'technical_analysis/indicators/sr'
+require 'technical_analysis/indicators/trix'
+require 'technical_analysis/indicators/tsi'
+require 'technical_analysis/indicators/uo'
+require 'technical_analysis/indicators/vi'
+require 'technical_analysis/indicators/vpt'
+require 'technical_analysis/indicators/wr'

data/lib/technical_analysis/helpers/array_helper.rb

@@ -0,0 +1,27 @@
+module TechnicalAnalysis
+  class ArrayHelper
+
+    def self.sum(data)
+      data.inject(0, :+)
+    end
+
+    def self.mean(data)
+      sum(data) / data.size.to_f
+    end
+
+    def self.average(data)
+      sum(data) / data.size.to_f
+    end
+
+    def self.sample_variance(data)
+      m = mean(data)
+      sum = data.inject(0) { |accum, i| accum + (i - m)**2 }
+      sum / (data.size - 1).to_f
+    end
+
+    def self.standard_deviation(data)
+      Math.sqrt(sample_variance(data))
+    end
+
+  end
+end

data/lib/technical_analysis/helpers/stock_calculation.rb

@@ -0,0 +1,25 @@
+module TechnicalAnalysis
+  class StockCalculation
+
+    def self.true_range(current_high, current_low, previous_close)
+      [
+        (current_high - current_low),
+        (current_high - previous_close).abs,
+        (current_low - previous_close).abs
+      ].max
+    end
+
+    def self.typical_price(price)
+      (price[:high] + price[:low] + price[:close]) / 3.0
+    end
+
+    def self.ema(current_value, data, period, prev_value)
+      if prev_value.nil?
+        ArrayHelper.average(data)
+      else
+        (current_value - prev_value) * (2.0 / (period + 1.0)) + prev_value
+      end
+    end
+
+  end
+end

data/lib/technical_analysis/helpers/validation.rb

@@ -0,0 +1,33 @@
+module TechnicalAnalysis
+  class Validation
+
+    def self.validate_numeric_data(data, *keys)
+      keys.each do |key|
+        unless data.all? { |v| v[key].is_a? Numeric }
+          raise ValidationError.new "Invalid Data. '#{key}' is not valid price data."
+        end
+      end
+    end
+
+    def self.validate_length(data, size)
+      raise ValidationError.new "Not enough data for that period" if data.size < size
+    end
+
+    def self.validate_options(options, valid_options)
+      raise ValidationError.new "Options must be a hash." unless options.respond_to? :keys
+      raise ValidationError.new "No valid options provided." unless valid_options
+
+      return true if (options.keys - valid_options).empty?
+      raise ValidationError.new "Invalid options provided. Valid options are #{valid_options.join(", ")}"
+    end
+  
+    def self.validate_date_time_key(data)
+      unless data.all? { |row| row.keys.include? :date_time }
+        raise ValidationError.new "Dataset must include date_time field with timestamps"
+      end
+    end
+
+    class ValidationError < StandardError; end
+
+  end
+end

data/lib/technical_analysis/indicators/adi.rb

@@ -0,0 +1,101 @@
+module TechnicalAnalysis
+  # Accumulation/Distribution Index
+  class Adi < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "adi"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Accumulation/Distribution Index"
+    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
+      []
+    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)
+      return true if options == {}
+      raise Validation::ValidationError.new "This indicator doesn't accept any 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(**params)
+      1
+    end
+
+    # Calculates the Accumulation/Distribution Index (ADI) for the given data
+    # https://en.wikipedia.org/wiki/Accumulation/distribution_index
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close, :volume)
+    # @return [Array<AdiValue>] An array of AdiValue instances
+    def self.calculate(data)
+      Validation.validate_numeric_data(data, :high, :low, :close, :volume)
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      ad = 0
+      clv = 0
+      output = []
+      prev_ad = 0
+
+      data.each_with_index do |values, i|
+        if values[:high] == values[:low]
+          clv = 0
+        else
+          clv = ((values[:close] - values[:low]) - (values[:high] - values[:close])) / (values[:high] - values[:low])
+        end
+
+        ad = prev_ad + (clv * values[:volume])
+        prev_ad = ad
+        date_time = values[:date_time]
+
+        output << AdiValue.new(date_time: date_time, adi: ad)
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class AdiValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the adi calculation value
+    attr_accessor :adi
+
+    def initialize(date_time: nil, adi: nil)
+      @date_time = date_time
+      @adi = adi
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, adi: @adi }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/adtv.rb

@@ -0,0 +1,98 @@
+module TechnicalAnalysis
+  # Average Daily Trading Volume
+  class Adtv < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "adtv"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Average Daily Trading Volume"
+    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 volume_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(period: 22, **params)
+      period.to_i
+    end
+
+    # Calculates the average daily trading volume (ADTV) for the data over the given period
+    # https://www.investopedia.com/terms/a/averagedailytradingvolume.asp
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param period [Integer] The given number of days used to calculate the ADTV
+    # @param volume_key [Symbol] The hash key for the volume data. Default :value
+    #
+    # @return [Array<AdtvValue>] An array of AdtvValue instances
+    def self.calculate(data, period: 22, volume_key: :value)
+      period = period.to_i
+      volume_key = volume_key.to_sym
+      Validation.validate_numeric_data(data, volume_key)
+      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|
+        period_values << v[volume_key]
+        if period_values.size == period
+          output << AdtvValue.new(date_time: v[:date_time], adtv: ArrayHelper.average(period_values))
+          period_values.shift
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class AdtvValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the adtv calculation value
+    attr_accessor :adtv
+
+    def initialize(date_time: nil, adtv: nil)
+      @date_time = date_time
+      @adtv = adtv
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, adtv: @adtv }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/adx.rb

@@ -0,0 +1,168 @@
+module TechnicalAnalysis
+  # Average Direcitonal Index
+  class Adx < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "adx"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Average Directional Index"
+    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: 14)
+      period.to_i * 2
+    end
+
+    # Calculates the average directional index (ADX) for the data over the given period
+    # https://en.wikipedia.org/wiki/Average_directional_movement_index
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close)
+    # @param period [Integer] The given period to calculate the ADX
+    #
+    # @return [Array<AdxValue>] An array of AdxValue instances
+    def self.calculate(data, period: 14)
+      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] }
+
+      dx_values = []
+      output = []
+      periodic_values = []
+      prev_adx = nil
+      prev_price = data.shift
+      smoothed_values = []
+
+      data.each do |v|
+        tr = StockCalculation.true_range(v[:high], v[:low], prev_price[:close])
+
+        dm_pos, dm_neg = calculate_dm(v, prev_price)
+
+        periodic_values << { tr: tr, dm_pos: dm_pos, dm_neg: dm_neg }
+
+        if periodic_values.size == period
+          tr_period, dm_pos_period, dm_neg_period = smooth_periodic_values(period, periodic_values, smoothed_values)
+          smoothed_values << { tr: tr_period, dm_pos: dm_pos_period, dm_neg: dm_neg_period }
+
+          di_pos = (dm_pos_period / tr_period) * 100.00
+          di_neg = (dm_neg_period / tr_period) * 100.00
+          dx = ((dm_pos_period - dm_neg_period).abs / (dm_pos_period + dm_neg_period) * 100.00)
+
+          dx_values << dx
+
+          if dx_values.size == period
+            if prev_adx.nil?
+              adx = ArrayHelper.average(dx_values)
+            else
+              adx = ((prev_adx * 13) + dx) / period.to_f
+            end
+
+            output << AdxValue.new(date_time: v[:date_time], adx: adx, di_pos: di_pos, di_neg: di_neg)
+
+            prev_adx = adx
+            dx_values.shift
+          end
+
+          periodic_values.shift
+        end
+
+        prev_price = v
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+    private_class_method def self.calculate_dm(current_price, prev_price)
+      if current_price[:high] - prev_price[:high] > prev_price[:low] - current_price[:low]
+        dm_pos = [(current_price[:high] - prev_price[:high]), 0].max
+        dm_neg = 0
+      elsif prev_price[:low] - current_price[:low] > current_price[:high] - prev_price[:high]
+        dm_pos = 0
+        dm_neg = [(prev_price[:low] - current_price[:low]), 0].max
+      else
+        dm_pos = 0
+        dm_neg = 0
+      end
+
+      [dm_pos, dm_neg]
+    end
+
+    private_class_method def self.smooth_periodic_values(period, periodic_values, smoothed_values)
+      if smoothed_values.empty?
+        tr_period = ArrayHelper.sum(periodic_values.map { |pv| pv[:tr] })
+        dm_pos_period = ArrayHelper.sum(periodic_values.map { |pv| pv[:dm_pos] })
+        dm_neg_period = ArrayHelper.sum(periodic_values.map { |pv| pv[:dm_neg] })
+      else
+        prev_value = smoothed_values.last
+        current_value = periodic_values.last
+
+        tr_period = prev_value[:tr] - (prev_value[:tr] / period) + current_value[:tr]
+        dm_pos_period = prev_value[:dm_pos] - (prev_value[:dm_pos] / period) + current_value[:dm_pos]
+        dm_neg_period = prev_value[:dm_neg] - (prev_value[:dm_neg] / period) + current_value[:dm_neg]
+      end
+
+      [tr_period, dm_pos_period, dm_neg_period]
+    end
+
+    # The value class to be returned by calculations
+    class AdxValue
+
+      # @return [String] the date_time of the obversation as it was provided
+      attr_accessor :date_time
+
+      # @return [Float] the adx calculation value
+      attr_accessor :adx
+
+      # @return [Float] the positive directional indicator calculation value
+      attr_accessor :di_pos
+
+      # @return [Float] the negative directional indicator calculation value
+      attr_accessor :di_neg
+
+      def initialize(date_time: nil, adx: nil, di_pos: nil, di_neg: nil)
+        @date_time = date_time
+        @adx = adx
+        @di_pos = di_pos
+        @di_neg = di_neg
+      end
+
+      # @return [Hash] the attributes as a hash
+      def to_hash
+        { date_time: @date_time, adx: @adx, di_pos: @di_pos, di_neg: @di_neg }
+      end
+
+    end
+
+  end
+end