technical-analysis 0.1.0

data/lib/technical_analysis/indicators/trix.rb

@@ -0,0 +1,127 @@
+module TechnicalAnalysis
+  # Triple Exponential Average
+  class Trix < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "trix"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Triple Exponential Average"
+    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 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(period: 15, **params)
+      (period.to_i * 3) - 1
+    end
+
+    # Calculates the triple exponential average (Trix) for the data over the given period
+    # https://en.wikipedia.org/wiki/Trix_(technical_analysis)
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param period [Integer] The given period to calculate the EMA for Trix
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<TrixValue>] An array of TrixValue instances
+    def self.calculate(data, period: 15, price_key: :value)
+      period = period.to_i
+      price_key = price_key.to_sym
+      Validation.validate_numeric_data(data, price_key)
+      Validation.validate_length(data, min_data_size(period: period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      ema1 = []
+      ema2 = []
+      ema3 = []
+      output = []
+      period_values = []
+
+      data.each do |v|
+        price = v[price_key]
+        period_values << price
+
+        if period_values.size == period
+          ema1_value = StockCalculation.ema(price, period_values, period, ema1.last)
+          ema1 << ema1_value
+
+          if ema1.size == period
+            ema2_value = StockCalculation.ema(ema1_value, ema1, period, ema2.last)
+            ema2 << ema2_value
+
+            if ema2.size == period
+              ema3_value = StockCalculation.ema(ema2_value, ema2, period, ema3.last)
+              ema3 << ema3_value
+
+              if ema3.size == 2
+                prev_ema3, current_ema3 = ema3
+                trix = ((current_ema3 - prev_ema3) / prev_ema3)
+                output << TrixValue.new(date_time: v[:date_time], trix: trix)
+
+                ema3.shift
+              end
+
+              ema2.shift
+            end
+
+            ema1.shift
+          end
+
+          period_values.shift
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class TrixValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the trix calculation value
+    attr_accessor :trix
+
+    def initialize(date_time: nil, trix: nil)
+      @date_time = date_time
+      @trix = trix
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, trix: @trix }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/tsi.rb

@@ -0,0 +1,139 @@
+module TechnicalAnalysis
+  # True Strength Index
+  class Tsi < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "tsi"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "True Strength 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(low_period high_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(low_period: 13, high_period: 25, **params)
+      low_period.to_i + high_period.to_i
+    end
+
+    # Calculates the true strength index (TSI) for the data over the given period
+    # https://en.wikipedia.org/wiki/True_strength_index
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param high_period [Integer] The given high period to calculate the EMA
+    # @param low_period [Integer] The given low period to calculate the EMA
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<TsiValue>] An array of TsiValue instances
+    def self.calculate(data, low_period: 13, high_period: 25, price_key: :value)
+      low_period = low_period.to_i
+      high_period = high_period.to_i
+      price_key = price_key.to_sym
+      Validation.validate_numeric_data(data, price_key)
+      Validation.validate_length(data, min_data_size(low_period: low_period, high_period: high_period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      high_emas = []
+      high_multiplier = (2.0 / (high_period + 1.0))
+      low_emas = []
+      low_multiplier = (2.0 / (low_period + 1.0))
+      momentum_values = []
+      output = []
+      prev_price = data.shift[price_key]
+
+      data.each do |v|
+        current_price = v[price_key]
+        momentum = current_price - prev_price
+        momentum_hash = { value: momentum, abs_value: momentum.abs }
+
+        momentum_values << momentum_hash
+
+        if momentum_values.size == high_period
+          high_emas << process_ema(momentum_hash, momentum_values, high_multiplier, high_period, high_emas)
+
+          if high_emas.size == low_period
+            low_ema = process_ema(high_emas.last, high_emas, low_multiplier, low_period, low_emas)
+            low_emas << low_ema
+
+            output << TsiValue.new(
+              date_time: v[:date_time],
+              tsi: ((100 * (low_ema[:value] / low_ema[:abs_value])))
+            )
+
+            low_emas.shift if low_emas.size > 1 # Only need to retain the last low_ema
+            high_emas.shift
+          end
+
+          momentum_values.shift
+        end
+
+        prev_price = current_price
+      end
+      
+      output.sort_by(&:date_time).reverse
+    end
+
+    private_class_method def self.process_ema(current_value, data, multiplier, period, store)
+      if store.empty?
+        value = ArrayHelper.average(data.map { |d| d[:value] })
+        abs_value = ArrayHelper.average(data.map { |d| d[:abs_value] })
+      else
+        prev_value = store.last
+        value = ((multiplier * (current_value[:value] - prev_value[:value])) + prev_value[:value])
+        abs_value = ((multiplier * (current_value[:abs_value] - prev_value[:abs_value])) + prev_value[:abs_value])
+      end
+
+      { value: value, abs_value: abs_value }
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class TsiValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the tsi calculation value
+    attr_accessor :tsi
+
+    def initialize(date_time: nil, tsi: nil)
+      @date_time = date_time
+      @tsi = tsi
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, tsi: @tsi }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/uo.rb

@@ -0,0 +1,130 @@
+module TechnicalAnalysis
+  # Ultimate Oscillator
+  class Uo < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "uo"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Ultimate Oscillator"
+    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(short_period medium_period long_period short_weight medium_weight long_weight)
+    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(long_period: 28, **params)
+      long_period.to_i + 1
+    end
+
+    # Calculates the ultimate oscillator (UO) for the data over the given period
+    # https://en.wikipedia.org/wiki/Ultimate_oscillator
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close)
+    # @param short_period [Integer] The given short period 
+    # @param medium_period [Integer] The given medium period 
+    # @param long_period [Integer] The given long period 
+    # @param short_weight [Float] Weight of short Buying Pressure average for UO
+    # @param medium_weight [Float] Weight of medium Buying Pressure average for UO
+    # @param long_weight [Float] Weight of long Buying Pressure average for UO
+    #
+    # @return [Array<UoValue>] An array of UoValue instances
+    def self.calculate(data, short_period: 7, medium_period: 14, long_period: 28, short_weight: 4, medium_weight: 2, long_weight: 1)
+      short_period = short_period.to_i
+      medium_period = medium_period.to_i
+      long_period = long_period.to_i
+      short_weight = short_weight.to_f
+      medium_weight = medium_weight.to_f
+      long_weight = long_weight.to_f
+      Validation.validate_numeric_data(data, :high, :low, :close)
+      Validation.validate_length(data, min_data_size(long_period: long_period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      output = []
+      period_values = []
+      prior_close = data.shift[:close]
+      sum_of_weights = ArrayHelper.sum([short_weight, medium_weight, long_weight])
+
+      data.each do |v|
+        min_low_p_close = [v[:low], prior_close].min
+        max_high_p_close = [v[:high], prior_close].max
+
+        buying_pressure = v[:close] - min_low_p_close
+        true_range = max_high_p_close - min_low_p_close
+
+        period_values << { buying_pressure: buying_pressure, true_range: true_range }
+
+        if period_values.size == long_period
+          short_average = calculate_average(short_period, period_values)
+          medium_average = calculate_average(medium_period, period_values)
+          long_average = calculate_average(long_period, period_values)
+          uo = 100 * (((short_weight * short_average) + (medium_weight * medium_average) + (long_weight * long_average)) / (sum_of_weights))
+
+          output << UoValue.new(date_time: v[:date_time], uo: uo)
+
+          period_values.shift
+        end
+
+        prior_close = v[:close]
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+    private_class_method def self.calculate_average(period, data)
+      buying_pressures_sum = ArrayHelper.sum(data.last(period).map { |d| d[:buying_pressure] })
+      true_ranges_sum = ArrayHelper.sum(data.last(period).map { |d| d[:true_range] })
+
+      buying_pressures_sum / true_ranges_sum
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class UoValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the uo calculation value
+    attr_accessor :uo
+
+    def initialize(date_time: nil, uo: nil)
+      @date_time = date_time
+      @uo = uo
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, uo: @uo }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/vi.rb

@@ -0,0 +1,117 @@
+module TechnicalAnalysis
+  # Vortex Indicator
+  class Vi < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "vi"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Vortex Indicator"
+    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 + 1
+    end
+
+    # Calculates the vortex indicator (VI) for the data over the given period
+    # https://en.wikipedia.org/wiki/Vortex_indicator
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close)
+    # @param period [Integer] The given period to calculate the VI
+    #
+    # @return [Array<Hash>] An array of ViValue 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] }
+
+      output = []
+      period_values = []
+      prev_price = data.shift
+
+      data.each do |v|
+        positive_vm = (v[:high] - prev_price[:low]).abs
+        negative_vm = (v[:low] - prev_price[:high]).abs
+        tr = [(v[:high] - v[:low]), (v[:high] - prev_price[:close]).abs, (v[:low] - prev_price[:close]).abs].max
+
+        period_values << { pos_vm: positive_vm, neg_vm: negative_vm, tr: tr }
+
+        if period_values.size == period
+          pos_vm_period = ArrayHelper.sum(period_values.map { |pv| pv[:pos_vm] })
+          neg_vm_period = ArrayHelper.sum(period_values.map { |pv| pv[:neg_vm] })
+          tr_period = ArrayHelper.sum(period_values.map { |pv| pv[:tr] })
+
+          output << ViValue.new(
+            date_time: v[:date_time],
+            positive_vi: (pos_vm_period / tr_period),
+            negative_vi: (neg_vm_period / tr_period),
+          )
+
+          period_values.shift
+        end
+
+        prev_price = v
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class ViValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the positive Vortex Indicator value
+    attr_accessor :positive_vi
+
+    # @return [Float] the negative Vortex Indicator value
+    attr_accessor :negative_vi
+
+    def initialize(date_time: nil, positive_vi: nil, negative_vi: nil)
+      @date_time = date_time
+      @positive_vi = positive_vi
+      @negative_vi = negative_vi
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, positive_vi: @positive_vi, negative_vi: @negative_vi }
+    end
+
+  end
+end