ruby-technical-analysis 0.1.1 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5daf0842421c382edf92ab3091c0dd0bb07182b78133724bdb5f3a0c602194bb
-  data.tar.gz: 8d7e60360f663a0156dec18fd28112e0f1ab5db87d3d8c1786ffc6d3a443a168
+  metadata.gz: fbed0351a5e66537192cbd5b27244ee4e4d8f7148ef513a594c55bb543ad3c01
+  data.tar.gz: 07513c6544f36eda98693cd137e365b36c6f532e75b889c1016bc64313f150e1
 SHA512:
-  metadata.gz: 47fbd9e1e23df84ded3562c94379e506eb64170407f3aaa104c584fbf8dfb518b1ae0648ae8cc1f6e50bf27674e6cc8faffea056ca2155bf33557b572f98f6ea
-  data.tar.gz: bac115dfd0edf9518aaf6ccd78a017e877ef7085472202b972deb8cbca6984ac045d03ced9c668570cd18bd1ca2ed7f2a08e9026f76d89af5f5cddedbc50735b
+  metadata.gz: 71d2b64e698c348059d573fbb998042fbe539c0f6d9244d884df651df51ab2e0d0c56384e3e9816d039a9a4cefbeb379edc282e86e2fc87956664034808d9c57
+  data.tar.gz: 95b7207c806a264af926d10c202087547332326a2fdb70485c88b7628c67cf9d64df2a5c8db2265d3c5e67600b5b9e8f24bd2d358b169d7ab8f2918e7ec3d69c

data/lib/ruby-technical-analysis.rb

@@ -0,0 +1 @@
+require "ruby_technical_analysis"

data/lib/ruby_technical_analysis/indicator.rb

@@ -0,0 +1,41 @@
+module RubyTechnicalAnalysis
+  # Base class for indicators
+  class Indicator
+    attr_reader :series
+
+    def self.call(**kwargs) # standard:disable Style/ArgumentsForwarding
+      new(**kwargs).call # standard:disable Style/ArgumentsForwarding
+    end
+
+    # @param series [Array] An array of prices
+    def initialize(series: [])
+      @series = series
+    end
+
+    private
+
+    def extract_series(subset_length: nil)
+      subset_length.nil? ? series : series.last(subset_length)
+    end
+
+    def extract_highs_lows_closes_volumes(subset_length: nil)
+      highs, lows, closes, volumes = extract_series(subset_length: subset_length).transpose
+
+      [highs, lows, closes, volumes]
+    end
+
+    def extract_highs_lows_closes(subset_length: nil)
+      highs, lows, closes = extract_series(subset_length: subset_length).transpose
+
+      [highs, lows, closes]
+    end
+
+    def moving_averages(subset_length: nil, period: nil)
+      RubyTechnicalAnalysis::MovingAverages.new(series: extract_series(subset_length: subset_length), period: period)
+    end
+
+    def statistical_methods(subset_length: nil)
+      RubyTechnicalAnalysis::StatisticalMethods.new(series: extract_series(subset_length: subset_length))
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/bollinger_bands.rb

@@ -0,0 +1,50 @@
+module RubyTechnicalAnalysis
+  # Bollinger Bands
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/bollinger-bands
+  class BollingerBands < Indicator
+    attr_reader :period, :standard_deviations
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param period [Integer] The number of periods to use in the calculation
+    # @param standard_deviations [Integer] The number of standard deviations to use in the calculation
+    def initialize(series: [], period: 20, standard_deviations: 2)
+      @period = period
+      @standard_deviations = standard_deviations
+
+      super(series: series)
+    end
+
+    # @return [Array] An array containing the current upper, middle, and lower bands of the series
+    def call
+      calculate_bollinger_bands
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length && standard_deviations > 0
+    end
+
+    private
+
+    def _middle_price
+      @_middle_price ||= moving_averages(period: period).sma
+    end
+
+    def _twice_sd
+      @_twice_sd ||= standard_deviations * statistical_methods.standard_deviation
+    end
+
+    def upper_band
+      _middle_price + _twice_sd
+    end
+
+    def lower_band
+      _middle_price - _twice_sd
+    end
+
+    def calculate_bollinger_bands
+      [upper_band, _middle_price, lower_band].map { |band| band.truncate(3) }
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/chaikin_money_flow.rb

@@ -0,0 +1,47 @@
+module RubyTechnicalAnalysis
+  # Chaikin Money Flow
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/cmf
+  class ChaikinMoneyFlow < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing high, low, close, and volume information, e.g. [[high, low, close, volume], [high, low, close, volume]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 21)
+      @period = period
+      @cmf_sum = 0
+      @vol_sum = 0
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Chaikin Money Flow value
+    def call
+      calculate_cmf
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length
+    end
+
+    private
+
+    def calculate_cmf_sum
+      highs, lows, closes, volumes = extract_highs_lows_closes_volumes(subset_length: period)
+
+      period.times do |index|
+        high, low, close, volume = highs.at(index), lows.at(index), closes.at(index), volumes.at(index)
+
+        @vol_sum += volume
+        @cmf_sum += (((close - low) - (high - close)).to_f / (high - low)) * volume
+      end
+    end
+
+    def calculate_cmf
+      calculate_cmf_sum
+
+      (@vol_sum.zero? ? 0 : @cmf_sum.to_f / @vol_sum).round(5)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/chande_momentum_oscillator.rb

@@ -0,0 +1,56 @@
+module RubyTechnicalAnalysis
+  # Chande Momentum Oscillator
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/cmo
+  class ChandeMomentumOscillator < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 20)
+      @period = period
+      @up_change_sum = 0
+      @down_change_sum = 0
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Chande Momentum Oscillator value
+    def call
+      calculate_cmo
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period + 1 <= series.length
+    end
+
+    private
+
+    def _closes
+      @_closes ||= extract_series(subset_length: period + 1)
+    end
+
+    def calculate_change_sums
+      (1..period).each do |index|
+        price_diff = _closes.at(index) - _closes.at(index - 1)
+        @up_change_sum += price_diff if price_diff.positive?
+        @down_change_sum -= price_diff if price_diff.negative?
+      end
+
+      @up_change_sum + @down_change_sum
+    end
+
+    def _up_sum_plus_down_sum
+      @_up_sum_plus_down_sum ||= calculate_change_sums
+    end
+
+    def calculate_oscillator_value
+      (@up_change_sum - @down_change_sum).to_f / _up_sum_plus_down_sum * 100
+    end
+
+    def calculate_cmo
+      _up_sum_plus_down_sum.zero? ? 0 : calculate_oscillator_value.round(4)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/commodity_channel_index.rb

@@ -0,0 +1,70 @@
+module RubyTechnicalAnalysis
+  # Commodity Channel Index
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/cci
+  class CommodityChannelIndex < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing high, low, close information, e.g. [[high, low, close], [high, low, close]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 20)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Commodity Channel Index value
+    def call
+      calculate_cci
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      min_size <= series.length
+    end
+
+    private
+
+    def min_size
+      (period * 2 - 1)
+    end
+
+    def calculate_typical_prices
+      highs, lows, closes = extract_highs_lows_closes(subset_length: min_size)
+
+      highs.zip(lows, closes).map { |high, low, close| (high + low + close) / 3 }
+    end
+
+    def _typical_prices
+      @_typical_prices ||= calculate_typical_prices
+    end
+
+    def _typical_prices_sma
+      @_typical_prices_sma ||=
+        _typical_prices.each_cons(period).map do |tp|
+          RubyTechnicalAnalysis::MovingAverages.new(series: tp, period: period).sma
+        end
+    end
+
+    def _period_sum
+      @_period_sum ||=
+        _typical_prices.last(period).sum do |tp|
+          (_typical_prices_sma.last - tp).abs
+        end
+    end
+
+    def _period_sum_next_period
+      @_period_sum_next_period ||=
+        (_period_sum.to_f / period) * 0.015
+    end
+
+    def _typical_prices_sma_minus_typical_prices
+      @_typical_prices_sma_minus_typical_prices ||=
+        _typical_prices.last(period).last - _typical_prices_sma.last
+    end
+
+    def calculate_cci
+      (_typical_prices_sma_minus_typical_prices.to_f / _period_sum_next_period)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/envelopes_ema.rb

@@ -0,0 +1,48 @@
+module RubyTechnicalAnalysis
+  # Envelopes EMA
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/mae
+  #
+  # Note that this indicator is similar but not the exact same as the one in the link above. This indicator is based on the EMA, not the SMA.
+  class EnvelopesEma < Indicator
+    attr_reader :period, :percent
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param period [Integer] The number of periods to use in the calculation
+    # @param percent [Integer] The percent to use in the calculation
+    def initialize(series: [], period: 20, percent: 5)
+      @period = period
+      @percent = percent
+
+      super(series: series)
+    end
+
+    # @return [Array] An array containing the current upper, middle, and lower bands of the series
+    def call
+      caluculate_envelopes_ema
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length && percent <= 100
+    end
+
+    private
+
+    def _eema
+      @_eema ||= moving_averages(period: period).ema
+    end
+
+    def eema_up
+      (_eema * (100 + percent)) / 100
+    end
+
+    def eema_down
+      (_eema * (100 - percent)) / 100
+    end
+
+    def caluculate_envelopes_ema
+      [eema_up, _eema, eema_down].map { |val| val.truncate(3) }
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/intraday_momentum_index.rb

@@ -0,0 +1,45 @@
+module RubyTechnicalAnalysis
+  # Intraday Momentum Index
+  #
+  # Find more information at: https://www.investopedia.com/terms/i/intraday-momentum-index-imi.asp
+  class IntradayMomentumIndex < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing open, close prices, e.g. [[open, close], [open, close]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 14)
+      @period = period
+      @gsum = 0
+      @lsum = 0
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Intraday Momentum Index value
+    def call
+      calculate_imi
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length
+    end
+
+    private
+
+    def calculate_gsum_plus_lsum
+      series.last(period).each do |open, close|
+        cmo = (close - open).abs
+        (close > open) ? @gsum += cmo : @lsum += cmo
+      end
+
+      @gsum + @lsum
+    end
+
+    def calculate_imi
+      gsum_plus_lsum = calculate_gsum_plus_lsum
+
+      (gsum_plus_lsum.zero? ? 0 : (@gsum / gsum_plus_lsum) * 100).round(4)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/macd.rb

@@ -0,0 +1,86 @@
+module RubyTechnicalAnalysis
+  # Moving Average Convergence Divergence (MACD)
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/macd
+  class Macd < Indicator
+    attr_reader :fast_period, :slow_period, :signal_period
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param fast_period [Integer] The number of periods to use in the fast calculation
+    # @param slow_period [Integer] The number of periods to use in the slow calculation
+    # @param signal_period [Integer] The number of periods to use in the signal calculation
+    def initialize(series: [], fast_period: 12, slow_period: 26, signal_period: 9)
+      @fast_period = fast_period
+      @slow_period = slow_period
+      @signal_period = signal_period
+
+      super(series: series)
+    end
+
+    # @return [Array] An array containing the current MACD line, signal line, and histogram values
+    def call
+      calculate_macd
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      series.length >= slow_period + signal_period
+    end
+
+    private
+
+    def fast_pct
+      (2.0 / (fast_period + 1)).truncate(6)
+    end
+
+    def slow_pct
+      (2.0 / (slow_period + 1)).truncate(6)
+    end
+
+    def period_array(percent)
+      period_values = Array(series.first)
+
+      series.drop(1).each_with_index do |value, index|
+        period_values << ((value * percent) + (period_values.last * (1 - percent))).round(3)
+      end
+
+      period_values
+    end
+
+    def _fast_period_array
+      @_fast_period_array ||= period_array(fast_pct)
+    end
+
+    def _slow_period_array
+      @_slow_period_array ||= period_array(slow_pct)
+    end
+
+    def _signal_array
+      @_signal_array ||= (0..signal_period - 1).map do |index|
+        calculated_index = slow_period + index - 1
+
+        (_fast_period_array.at(calculated_index) - _slow_period_array.at(calculated_index)).round(3)
+      end
+    end
+
+    def _signal_pct
+      @_signal_pct ||= (2.0 / (signal_period + 1)).truncate(6)
+    end
+
+    def _signal
+      @_signal ||= ((_signal_array.last * _signal_pct) + (_signal_array.at(-2) * (1 - _signal_pct))).round(3)
+    end
+
+    def _macd_line
+      @_macd_line ||= (_fast_period_array.last - _slow_period_array.last).round(4)
+    end
+
+    def histogram
+      (_macd_line - _signal).round(3)
+    end
+
+    def calculate_macd
+      [_macd_line, _signal, histogram]
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/mass_index.rb

@@ -0,0 +1,70 @@
+module RubyTechnicalAnalysis
+  # Mass Index
+  #
+  # Find more information at: https://www.investopedia.com/terms/m/mass-index.asp
+  class MassIndex < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing high and low prices, e.g. [[high, low], [high, low]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 9)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Mass Index value
+    def call
+      calculate_mass_index
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      series.length >= _full_period
+    end
+
+    private
+
+    def _highs
+      @_highs ||= series.map(&:first).last(_full_period)
+    end
+
+    def lows
+      series.map(&:last).last(_full_period)
+    end
+
+    def _full_period
+      @_full_period ||= (2 * period + 1)
+    end
+
+    def _low_multiple
+      @_low_multiple ||= (2.0 / (period + 1)).truncate(4)
+    end
+
+    def high_multiple
+      1 - _low_multiple
+    end
+
+    def high_minus_low_array
+      (0..(_highs.size - 1)).map { |index| _highs.at(index) - lows.at(index) }
+    end
+
+    def _high_minus_low_ema_array
+      @_high_minus_low_ema_array ||= high_minus_low_array.each_with_index.reduce([]) do |arr, (value, index)|
+        arr << (index.zero? ? value.truncate(4) : ((value * _low_multiple) + (arr.at(index - 1) * high_multiple)).truncate(4))
+      end
+    end
+
+    def high_minus_low_ema_ema_array
+      [*0..period + 1].each.reduce([]) do |arr, index|
+        arr << (index.zero? ? _high_minus_low_ema_array.at(period - index - 1) : ((_high_minus_low_ema_array.at(period + index - 1) * 0.2) + (arr.last * 0.8)).round(4))
+      end
+    end
+
+    def calculate_mass_index
+      [*0..2].each.sum do |index|
+        (_high_minus_low_ema_array.at((period * 2) + index - 2) / high_minus_low_ema_ema_array.at(period + index - 1))
+      end.round(4)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/moving_averages.rb

@@ -0,0 +1,71 @@
+module RubyTechnicalAnalysis
+  # Moving Averages
+  #
+  # Find more information at:
+  #
+  # Simple Moving Average (SMA): https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/sma
+  #
+  # Exponential Moving Average (EMA): https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/ema
+  #
+  # Weighted Moving Average (WMA): https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/wma
+  class MovingAverages < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 20)
+      @period = period
+
+      super(series: series)
+    end
+
+    # Simple Moving Average
+    # @return [Float] The current SMA value
+    def sma
+      series.last(period).sum.to_f / period
+    end
+
+    # Exponential Moving Average
+    # @return [Float] The current EMA value
+    def ema
+      return series.last if period == 1
+
+      series.last(period).each_with_object([]) do |num, result|
+        result << if result.empty?
+          num
+        else
+          (num * _ema_percentages.first) + (result.last * _ema_percentages.last)
+        end
+      end.last
+    end
+
+    # Weighted Moving Average
+    # @return [Float] The current WMA value
+    def wma
+      true_periods = (1..period).sum
+
+      sigma_periods = series.last(period).each_with_index.sum { |num, index| (index + 1) * num }
+
+      sigma_periods.to_f / true_periods
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length
+    end
+
+    private
+
+    def _ema_percentages
+      @_ema_percentages ||=
+        case period
+        when 12 then [0.846154, 0.153846]
+        when 26 then [0.925926, 0.074074]
+        else
+          last_obs_pct = 2.0 / (period + 1)
+
+          [last_obs_pct, 1 - last_obs_pct]
+        end
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/pivot_points.rb

@@ -0,0 +1,75 @@
+module RubyTechnicalAnalysis
+  # Pivot Points
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/pivot-points
+  class PivotPoints < Indicator
+    # @param series [Array] An array of high, low, and closing prices for a single period
+    # def initialize(series: [])
+    #   super(series: series)
+    # end
+
+    # @return [Array] An array containing the current S3, S2, S1, pivot, R1, R2, and R3 values
+    def call
+      calculate_pivot_points
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      series.length == 3
+    end
+
+    private
+
+    def _high
+      @_high ||= series.first
+    end
+
+    def _low
+      @_low ||= series.at(1)
+    end
+
+    def _close
+      @_close ||= series.last
+    end
+
+    def _pivot
+      @_pivot ||= ((_high + _low + _close) / 3.0).round(2)
+    end
+
+    def support_one
+      ((2 * _pivot) - _high).round(2)
+    end
+
+    def support_two
+      (_pivot - (_high - _low)).round(2)
+    end
+
+    def support_three
+      (_low - (2 * (_high - _pivot))).round(2)
+    end
+
+    def resistance_one
+      ((2 * _pivot) - _low).round(2)
+    end
+
+    def resistance_two
+      (_pivot + (_high - _low)).round(2)
+    end
+
+    def resistance_three
+      (_high + (2 * (_pivot - _low))).round(2)
+    end
+
+    def calculate_pivot_points
+      [
+        support_three,
+        support_two,
+        support_one,
+        _pivot,
+        resistance_one,
+        resistance_two,
+        resistance_three
+      ]
+    end
+  end
+end