technical-analysis 0.1.0

data/lib/technical_analysis/indicators/obv_mean.rb

@@ -0,0 +1,110 @@
+module TechnicalAnalysis
+  # On-balance Volume Mean
+  class ObvMean < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "obv_mean"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "On-balance Volume Mean"
+    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 + 1
+    end
+
+    # Calculates the on-balance volume mean (OBV mean) for the data over the given period
+    # https://en.wikipedia.org/wiki/On-balance_volume
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :close, :volume)
+    # @param period [Integer] The given period to calculate the OBV mean
+    #
+    # @return [Array<ObvMeanValue>] An array of ObvMeanValue instances
+    def self.calculate(data, period: 10)
+      period = period.to_i
+      Validation.validate_numeric_data(data, :close, :volume)
+      Validation.validate_length(data, min_data_size(period: period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      current_obv = 0
+      obvs = []
+      output = []
+      prior_close = nil
+      prior_volume = nil
+
+      data.each do |v|
+        volume = v[:volume]
+        close = v[:close]
+
+        unless prior_close.nil?
+          current_obv += volume if close > prior_close
+          current_obv -= volume if close < prior_close
+          obvs << current_obv
+        end
+
+        prior_volume = volume
+        prior_close = close
+
+        if obvs.size == period
+          output << ObvMeanValue.new(date_time: v[:date_time], obv_mean: ArrayHelper.average(obvs))
+          obvs.shift
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class ObvMeanValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the obv_mean calculation value
+    attr_accessor :obv_mean
+
+    def initialize(date_time: nil, obv_mean: nil)
+      @date_time = date_time
+      @obv_mean = obv_mean
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, obv_mean: @obv_mean }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/rsi.rb

@@ -0,0 +1,133 @@
+module TechnicalAnalysis
+  # Relative Strength Index
+  class Rsi < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "rsi"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Relative 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(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: 14, **params)
+      period.to_i + 1
+    end
+
+    # Calculates the relative strength index for the data over the given period
+    # https://en.wikipedia.org/wiki/Relative_strength_index
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param period [Integer] The given period to calculate the RSI
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<RsiValue>] An array of RsiValue instances
+    def self.calculate(data, period: 14, 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] }
+
+      output = []
+      prev_price = data.shift[price_key]
+      prev_avg = nil
+      price_changes = []
+      smoothing_period = period - 1
+
+      data.each do |v|
+        price_change = (v[price_key] - prev_price)
+        price_changes << price_change
+
+        if price_changes.size == period
+          if prev_avg.nil?
+            avg_gain = ArrayHelper.average(price_changes.map { |pc| pc.positive? ? pc : 0 })
+            avg_loss = ArrayHelper.average(price_changes.map { |pc| pc.negative? ? pc.abs : 0 })
+          else
+            if price_change > 0
+              current_loss = 0
+              current_gain = price_change
+            elsif price_change < 0
+              current_loss = price_change.abs
+              current_gain = 0
+            else
+              current_loss = 0
+              current_gain = 0
+            end
+
+            avg_gain = (((prev_avg[:gain] * smoothing_period) + current_gain) / period.to_f)
+            avg_loss = (((prev_avg[:loss] * smoothing_period) + current_loss) / period.to_f)
+          end
+
+          if avg_loss == 0
+            rsi = 100
+          else
+            rs = avg_gain / avg_loss
+            rsi = (100.00 - (100.00 / (1.00 + rs)))
+          end
+
+          output << RsiValue.new(date_time: v[:date_time], rsi: rsi)
+
+          prev_avg = { gain: avg_gain, loss: avg_loss }
+          price_changes.shift
+        end
+
+        prev_price = v[price_key]
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class RsiValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the rsi calculation value
+    attr_accessor :rsi
+
+    def initialize(date_time: nil, rsi: nil)
+      @date_time = date_time
+      @rsi = rsi
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, rsi: @rsi }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/sma.rb

@@ -0,0 +1,98 @@
+module TechnicalAnalysis
+  # Simple Moving Average
+  class Sma < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "sma"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Simple Moving 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: 30, **params)
+      period.to_i
+    end
+
+    # Calculates the simple moving average (SMA) for the data over the given period
+    # https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :value)
+    # @param period [Integer] The given period to calculate the SMA
+    # @param price_key [Symbol] The hash key for the price data. Default :value
+    #
+    # @return [Array<SmaValue>] An array of SmaValue instances
+    def self.calculate(data, period: 30, 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] }
+
+      output = []
+      period_values = []
+
+      data.each do |v|
+        period_values << v[price_key]
+        if period_values.size == period
+          output << SmaValue.new(date_time: v[:date_time], sma: 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 SmaValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the sma calculation value
+    attr_accessor :sma
+
+    def initialize(date_time: nil, sma: nil)
+      @date_time = date_time
+      @sma = sma
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, sma: @sma }
+    end
+
+  end
+end

data/lib/technical_analysis/indicators/sr.rb

@@ -0,0 +1,122 @@
+module TechnicalAnalysis
+  # Stochastic Oscillator
+  class Sr < Indicator
+
+    # Returns the symbol of the technical indicator
+    #
+    # @return [String] A string of the symbol of the technical indicator
+    def self.indicator_symbol
+      "sr"
+    end
+
+    # Returns the name of the technical indicator
+    #
+    # @return [String] A string of the name of the technical indicator
+    def self.indicator_name
+      "Stochastic 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(period signal_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, signal_period: 3)
+      period.to_i + signal_period.to_i - 1
+    end
+
+    # Calculates the stochastic oscillator (%K) for the data over the given period
+    # https://en.wikipedia.org/wiki/Stochastic_oscillator
+    #
+    # @param data [Array] Array of hashes with keys (:date_time, :high, :low, :close)
+    # @param period [Integer] The given period to calculate the SR
+    # @param signal_period [Integer] The given period to calculate the SMA as a signal line for SR
+    #
+    # @return [Array<SrValue>] An array of SrValue instances
+    def self.calculate(data, period: 14, signal_period: 3)
+      period = period.to_i
+      signal_period = signal_period.to_i
+      Validation.validate_numeric_data(data, :high, :low, :close)
+      Validation.validate_length(data, min_data_size(period: period, signal_period: signal_period))
+      Validation.validate_date_time_key(data)
+
+      data = data.sort_by { |row| row[:date_time] }
+
+      high_low_values = []
+      output = []
+      sr_values = []
+
+      data.each do |v|
+        high_low_values << { high: v[:high], low: v[:low] }
+
+        if high_low_values.size == period
+          lowest_low = high_low_values.map { |hlv| hlv[:low] }.min
+          highest_high = high_low_values.map { |hlv| hlv[:high] }.max
+
+          sr = (v[:close] - lowest_low) / (highest_high - lowest_low) * 100.00
+
+          sr_values << sr
+
+          if sr_values.size == signal_period
+            signal = ArrayHelper.average(sr_values)
+
+            output << SrValue.new(
+              date_time: v[:date_time],
+              sr: sr,
+              sr_signal: signal
+            )
+
+            sr_values.shift
+          end
+
+          high_low_values.shift
+        end
+      end
+
+      output.sort_by(&:date_time).reverse
+    end
+
+  end
+
+  # The value class to be returned by calculations
+  class SrValue
+
+    # @return [String] the date_time of the obversation as it was provided
+    attr_accessor :date_time
+
+    # @return [Float] the sr calculation value
+    attr_accessor :sr
+
+    # @return [Float] the sr_signal calculation value
+    attr_accessor :sr_signal
+
+    def initialize(date_time: nil, sr: nil, sr_signal: nil)
+      @date_time = date_time
+      @sr = sr
+      @sr_signal = sr_signal
+    end
+
+    # @return [Hash] the attributes as a hash
+    def to_hash
+      { date_time: @date_time, sr: @sr, sr_signal: @sr_signal }
+    end
+
+  end
+end