ruby-technical-analysis 0.1.1 → 1.0.3

data/lib/ruby_technical_analysis/indicators/price_channel.rb

@@ -0,0 +1,43 @@
+module RubyTechnicalAnalysis
+  # Price Channel
+  #
+  # Find more information at: https://www.investopedia.com/terms/p/price-channel.asp
+  class PriceChannel < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing high, low prices, e.g. [[high, low], [high, low]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 20)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Array] An array containing the current upper and lower price channel values
+    def call
+      calculate_price_channel
+    end
+
+    private
+
+    def _highs
+      @_highs ||= series.last(period + 1).map { |value| value.at(0) }
+    end
+
+    def _lows
+      @_lows ||= series.last(period + 1).map { |value| value.at(1) }
+    end
+
+    def upper_price_channel
+      _highs[0..period - 1].max
+    end
+
+    def lower_price_channel
+      _lows[0..period - 1].min
+    end
+
+    def calculate_price_channel
+      [upper_price_channel, lower_price_channel]
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/qstick.rb

@@ -0,0 +1,44 @@
+module RubyTechnicalAnalysis
+  # Qstick
+  #
+  # Find more information at: https://www.investopedia.com/terms/q/qstick.asp
+  class QStick < 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: 20)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Qstick value
+    def call
+      calculate_qstick
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period <= series.length
+    end
+
+    private
+
+    def _opens
+      @_opens ||= series.last(period).map { |value| value.at(0) }
+    end
+
+    def _closes
+      @_closes ||= series.last(period).map { |value| value.at(1) }
+    end
+
+    def cmo_sum
+      _closes.zip(_opens).sum { |close, open| close - open }
+    end
+
+    def calculate_qstick
+      (cmo_sum.to_f / period).round(4)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/rate_of_change.rb

@@ -0,0 +1,40 @@
+module RubyTechnicalAnalysis
+  # Rate Of Change
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/roc
+  class RateOfChange < 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: 30)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current ROC value
+    def call
+      calculate_roc
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period + 1 <= series.length
+    end
+
+    private
+
+    def calculate_roc
+      (((current_price - lookback_price).to_f / lookback_price) * 100).round(2)
+    end
+
+    def current_price
+      series.last
+    end
+
+    def lookback_price
+      series.last(period + 1).first
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/relative_momentum_index.rb

@@ -0,0 +1,79 @@
+module RubyTechnicalAnalysis
+  # Relative Momentum Index
+  class RelativeMomentumIndex < Indicator
+    attr_reader :period_mom, :period_rmi
+
+    # @param series [Array] An array of prices, typically closing prices
+    # @param period_mom [Integer] The number of periods to use in the momentum calculation
+    # @param period_rmi [Integer] The number of periods to use in the RMI calculation
+    def initialize(series: [], period_mom: 14, period_rmi: 20)
+      @period_mom = period_mom
+      @period_rmi = period_rmi
+      @rmi = []
+      @rmi_intermediate = []
+      @smooth_up = []
+      @smooth_down = []
+      @wilders_is_set = false
+
+      super(series: series)
+    end
+
+    # @return [Float] The current RMI value
+    def call
+      calculate_rmi
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period_mom + period_rmi <= series.length
+    end
+
+    private
+
+    def _pmpr
+      @_pmpr ||= (period_mom + period_rmi)
+    end
+
+    def _smooth_coef_one
+      @_smooth_coef_one ||= (1.0 / period_rmi).round(4)
+    end
+
+    def _smooth_coef_two
+      @_smooth_coef_two ||= (1 - _smooth_coef_one)
+    end
+
+    def calculate_channels(cla)
+      period_rmi.times.map do |index|
+        diff = (cla.at(index) - cla.at(period_mom + index)).round(4)
+        [diff.negative? ? diff.abs : 0, diff.positive? ? diff : 0]
+      end.transpose
+    end
+
+    def calculate_initial_smoothing(up_ch, down_ch)
+      @smooth_up << RubyTechnicalAnalysis::WildersSmoothing.call(series: up_ch, period: period_rmi)
+      @smooth_down << RubyTechnicalAnalysis::WildersSmoothing.call(series: down_ch, period: period_rmi)
+      @wilders_is_set = true
+    end
+
+    def calculate_subsequent_smoothing(up_ch, down_ch)
+      @smooth_up << (_smooth_coef_one * up_ch.last + _smooth_coef_two * @smooth_up.last).round(4)
+      @smooth_down << (_smooth_coef_one * down_ch.last + _smooth_coef_two * @smooth_down.last).round(4)
+    end
+
+    def calculate_smoothing(up_ch, down_ch)
+      @wilders_is_set ? calculate_subsequent_smoothing(up_ch, down_ch) : calculate_initial_smoothing(up_ch, down_ch)
+    end
+
+    def calculate_rmi
+      (0..(series.size - _pmpr)).flat_map do |index|
+        cla = series[index..(index + _pmpr - 1)]
+        up_ch, down_ch = calculate_channels(cla)
+
+        calculate_smoothing(up_ch, down_ch)
+
+        @rmi_intermediate << (@smooth_up.last.to_f / @smooth_down.last)
+        @rmi << ((@rmi_intermediate.last.to_f / (1 + @rmi_intermediate.last)) * 100).round(4)
+      end.last
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/relative_strength_index.rb

@@ -0,0 +1,74 @@
+module RubyTechnicalAnalysis
+  # Relative Strength Index
+  #
+  # Find more information at: https://www.fidelity.com/viewpoints/active-investor/how-to-use-RSI
+  class RelativeStrengthIndex < 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: 14)
+      @period = period
+      @rsi = []
+      @smooth_up = []
+      @smooth_down = []
+      @wilders_is_set = false
+
+      super(series: series)
+    end
+
+    # @return [Float] The current RSI value
+    def call
+      calculate_rsi
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period < series.length
+    end
+
+    private
+
+    def _smooth_coef_one
+      @_smooth_coef_one ||= (1.0 / period).round(4)
+    end
+
+    def _smooth_coef_two
+      @_smooth_coef_two ||= (1 - _smooth_coef_one)
+    end
+
+    def calculate_channels(cla)
+      period.times.map do |index|
+        diff = (cla.at(index) - cla.at(index + 1)).round(4)
+
+        [diff.negative? ? diff.abs : 0, diff.positive? ? diff : 0]
+      end.transpose
+    end
+
+    def calculate_initial_smoothing(up_ch, down_ch)
+      @smooth_up << RubyTechnicalAnalysis::WildersSmoothing.call(series: up_ch, period: period)
+      @smooth_down << RubyTechnicalAnalysis::WildersSmoothing.call(series: down_ch, period: period)
+
+      @wilders_is_set = true
+    end
+
+    def calculate_subsequent_smoothing(up_ch, down_ch)
+      @smooth_up << (_smooth_coef_one * up_ch.last + _smooth_coef_two * @smooth_up.last).round(4)
+      @smooth_down << (_smooth_coef_one * down_ch.last + _smooth_coef_two * @smooth_down.last).round(4)
+    end
+
+    def calculate_smoothing(up_ch, down_ch)
+      @wilders_is_set ? calculate_subsequent_smoothing(up_ch, down_ch) : calculate_initial_smoothing(up_ch, down_ch)
+    end
+
+    def calculate_rsi
+      (0..(series.size - period - 1)).flat_map do |index|
+        cla = series[index..index + period]
+        up_ch, down_ch = calculate_channels(cla)
+
+        calculate_smoothing(up_ch, down_ch)
+        @rsi << (100.00 - (100.00 / ((@smooth_up.last.to_f / @smooth_down.last) + 1))).round(4)
+      end.last
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/statistical_methods.rb

@@ -0,0 +1,40 @@
+module RubyTechnicalAnalysis
+  # Statistical Methods
+  class StatisticalMethods < Indicator
+    # @param series [Array] An array of prices, typically closing prices
+    # def initialize(series: [])
+    #  super(series: series)
+    # end
+
+    # Mean
+    # @return [Float] The mean of the price series
+    def mean
+      series.reduce(:+) / series.length.to_f
+    end
+
+    # Standard Deviation
+    # @return [Float] The standard deviation of the price series
+    def standard_deviation
+      return 0 if series.uniq.length == 1
+
+      Math.sqrt(variance)
+    end
+
+    # Variance
+    # @return [Float] The variance of the price series
+    def variance
+      squared_differences.reduce(:+) / series.length.to_f
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      series.length > 0
+    end
+
+    private
+
+    def squared_differences
+      series.map { |value| (value - mean)**2 }
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/stochastic_oscillator.rb

@@ -0,0 +1,99 @@
+module RubyTechnicalAnalysis
+  # Stochastic Oscillator
+  #
+  # Find more information at: https://www.investopedia.com/terms/s/stochasticoscillator.asp
+  class StochasticOscillator < Indicator
+    attr_reader :k_periods, :k_slow_periods, :d_periods
+
+    # @param series [Array] An array of arrays containing high, low, close prices, e.g. [[high, low, close], [high, low, close]]
+    # @param k_periods [Integer] The number of periods to use in the calculation
+    # @param k_slow_periods [Integer] The number of periods to use in the calculation
+    # @param d_periods [Integer] The number of periods to use in the calculation
+    def initialize(series: [], k_periods: 14, k_slow_periods: 3, d_periods: 3)
+      @k_periods = k_periods
+      @k_slow_periods = k_slow_periods
+      @d_periods = d_periods
+      @lowest_lows = []
+      @highest_highs = []
+      @close_minus_lowest_lows = []
+      @highest_highs_minus_lowest_lows = []
+      @ks_sums_close_minus_lowest_lows = []
+      @ks_sums_highest_highs_minus_lowest_lows = []
+      @ks_sums_quotients_times_one_hundred = []
+      @d_periods_sma = []
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Stochastic Oscillator value
+    def call
+      calculate_stochastic_oscillator
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      k_periods + d_periods <= series.length
+    end
+
+    private
+
+    def calculate_lowest_lows(lows, window_start)
+      @lowest_lows << lows[window_start..(window_start + k_periods - 1)].min
+    end
+
+    def calculate_highest_highs(highs, window_start)
+      @highest_highs << highs[window_start..(window_start + k_periods - 1)].max
+    end
+
+    def calculate_close_minus_lowest_lows(closes, window_start)
+      @close_minus_lowest_lows <<
+        (closes.at(window_start + k_periods - 1) - @lowest_lows.last).round(4)
+    end
+
+    def calculate_highest_highs_minus_lowest_lows
+      @highest_highs_minus_lowest_lows << (@highest_highs.last - @lowest_lows.last).round(4)
+    end
+
+    def calculate_ks_sums_close_minus_lowest_lows
+      @ks_sums_close_minus_lowest_lows <<
+        @close_minus_lowest_lows.last(k_slow_periods).sum.round(4)
+    end
+
+    def calculate_ks_sums_highest_highs_minus_lowest_lows
+      @ks_sums_highest_highs_minus_lowest_lows <<
+        @highest_highs_minus_lowest_lows.last(k_slow_periods).sum.round(4)
+    end
+
+    def calculate_ks_sums_quotients_times_one_hundred
+      @ks_sums_quotients_times_one_hundred <<
+        ((@ks_sums_close_minus_lowest_lows.last.to_f / @ks_sums_highest_highs_minus_lowest_lows.last) * 100).round(4)
+    end
+
+    def caculate_d_periods_sma
+      @d_periods_sma << if @ks_sums_quotients_times_one_hundred.length >= d_periods
+        (@ks_sums_quotients_times_one_hundred.last(d_periods).sum.to_f / d_periods).round(4)
+      else
+        -1000
+      end
+    end
+
+    def calculate_stochastic_oscillator
+      highs, lows, closes = extract_highs_lows_closes
+
+      (0..(highs.length - k_periods)).flat_map do |index|
+        calculate_lowest_lows(lows, index)
+        calculate_highest_highs(highs, index)
+        calculate_close_minus_lowest_lows(closes, index)
+        calculate_highest_highs_minus_lowest_lows
+
+        if @close_minus_lowest_lows.length >= k_slow_periods
+          calculate_ks_sums_close_minus_lowest_lows
+          calculate_ks_sums_highest_highs_minus_lowest_lows
+          calculate_ks_sums_quotients_times_one_hundred
+        end
+
+        caculate_d_periods_sma
+      end.last
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/volume_oscillator.rb

@@ -0,0 +1,50 @@
+module RubyTechnicalAnalysis
+  # Volume Oscillator
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/volume-oscillator
+  class VolumeOscillator < Indicator
+    attr_reader :short_ma_period, :long_ma_period
+
+    # @param series [Array] An array of volume values
+    # @param short_ma_period [Integer] The number of periods to use in the calculation of the short moving average
+    # @param long_ma_period [Integer] The number of periods to use in the calculation of the long moving average
+    def initialize(series: [], short_ma_period: 20, long_ma_period: 60)
+      @short_ma_period = short_ma_period
+      @long_ma_period = long_ma_period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current volume oscillator value
+    def call
+      calculate_volume_oscillator
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      short_ma_period < long_ma_period && long_ma_period <= series.length
+    end
+
+    private
+
+    def short_ma_a
+      (0..(series.length - short_ma_period)).map do |index|
+        RubyTechnicalAnalysis::MovingAverages.new(series: series[index..(index + short_ma_period - 1)], period: short_ma_period).sma
+      end
+    end
+
+    def _long_ma_a
+      @_long_ma_a ||= (0..(series.length - long_ma_period)).map do |index|
+        RubyTechnicalAnalysis::MovingAverages.new(series: series[index..(index + long_ma_period - 1)], period: long_ma_period).sma
+      end
+    end
+
+    def short_minus_long_ma_a
+      (short_ma_a.last - _long_ma_a.last).round(2)
+    end
+
+    def calculate_volume_oscillator
+      ((short_minus_long_ma_a.to_f / _long_ma_a.last) * 100).round(2)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/volume_rate_of_change.rb

@@ -0,0 +1,48 @@
+module RubyTechnicalAnalysis
+  # Volume Rate of Change
+  #
+  # Find more information at: https://www.investopedia.com/articles/technical/02/091002.asp
+  class VolumeRateOfChange < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of volume values
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 25)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current volume rate of change value
+    def call
+      calculate_volume_rate_of_change
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period < series.length
+    end
+
+    private
+
+    def _calculable_series_length
+      @_calculable_series_length ||= series.length - period
+    end
+
+    def _vol_shifted
+      @_vol_shifted ||= _calculable_series_length.times.map do
+        series.at(_calculable_series_length - 1)
+      end
+    end
+
+    def delta_volume
+      _calculable_series_length.times.map do
+        series.last - _vol_shifted.last
+      end
+    end
+
+    def calculate_volume_rate_of_change
+      ((delta_volume.last.to_f / _vol_shifted.last) * 100).round(4)
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/wilders_smoothing.rb

@@ -0,0 +1,47 @@
+module RubyTechnicalAnalysis
+  # Wilders Smoothing
+  class WildersSmoothing < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of prices
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 5)
+      @period = period
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Wilders Smoothing value
+    def call
+      calculate_wilders_smoothing
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period < series.length
+    end
+
+    private
+
+    def _sma_first_period
+      @_sma_first_period ||=
+        Array(RubyTechnicalAnalysis::MovingAverages.new(series: series.first(period), period: period).sma)
+    end
+
+    def smoothing_length
+      (series.size - period - 1)
+    end
+
+    def calculate_wilders_smoothing
+      ws = _sma_first_period
+
+      (0..smoothing_length).each do |index|
+        current_smoothing = ws.at(index)
+
+        ws << ((series.at(index + period) - current_smoothing) * (1.0 / period)) + current_smoothing
+      end
+
+      ws.last
+    end
+  end
+end

data/lib/ruby_technical_analysis/indicators/williams_percent_r.rb

@@ -0,0 +1,69 @@
+module RubyTechnicalAnalysis
+  # Williams %R
+  #
+  # Find more information at: https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/williams-r
+  class WilliamsPercentR < Indicator
+    attr_reader :period
+
+    # @param series [Array] An array of arrays containing high, low, close prices, e.g. [[high, low, close], [high, low, close]]
+    # @param period [Integer] The number of periods to use in the calculation
+    def initialize(series: [], period: 14)
+      @period = period
+      @highest_highs = []
+      @lowest_lows = []
+      @highest_highs_minus_close = []
+      @highest_highs_minus_lowest_lows = []
+      @pct_r = []
+
+      super(series: series)
+    end
+
+    # @return [Float] The current Williams %R value
+    def call
+      calculate_williams_percent_r
+    end
+
+    # @return [Boolean] Whether or not the object is valid
+    def valid?
+      period < series.length
+    end
+
+    private
+
+    def calculate_lowest_lows(lows, window_start)
+      @lowest_lows << lows[window_start..(period - 1 + window_start)].min
+    end
+
+    def calculate_highest_highs(highs, window_start)
+      @highest_highs << highs[window_start..(period - 1 + window_start)].max
+    end
+
+    def calculate_highest_highs_minus_close(closes, window_start)
+      @highest_highs_minus_close <<
+        (@highest_highs.last - closes.at(period - 1 + window_start)).round(2)
+    end
+
+    def calculate_highest_highs_minus_lowest_lows
+      @highest_highs_minus_lowest_lows << (@highest_highs.last - @lowest_lows.last).round(4)
+    end
+
+    def calculate_pct_r
+      @pct_r <<
+        ((@highest_highs_minus_close.last.to_f / @highest_highs_minus_lowest_lows.last) * -100).round(2)
+    end
+
+    def calculate_williams_percent_r
+      highs, lows, closes = extract_highs_lows_closes
+
+      (0..highs.length - period).each do |index|
+        calculate_highest_highs(highs, index)
+        calculate_lowest_lows(lows, index)
+        calculate_highest_highs_minus_close(closes, index)
+        calculate_highest_highs_minus_lowest_lows
+        calculate_pct_r
+      end
+
+      @pct_r.last
+    end
+  end
+end

data/lib/ruby_technical_analysis.rb

@@ -1,8 +1,25 @@
-# frozen_string_literal: true
+# Base class
+require "ruby_technical_analysis/indicator"
 
-Dir[File.join(__dir__, "ruby-technical-analysis/**/", "*.rb")].sort.each { |f| require f }
-
-# module for Ruby Technical Analysis
-module RubyTechnicalAnalysis
-  class Error < StandardError; end
-end
+# Indicators
+require "ruby_technical_analysis/indicators/bollinger_bands"
+require "ruby_technical_analysis/indicators/chaikin_money_flow"
+require "ruby_technical_analysis/indicators/chande_momentum_oscillator"
+require "ruby_technical_analysis/indicators/commodity_channel_index"
+require "ruby_technical_analysis/indicators/envelopes_ema"
+require "ruby_technical_analysis/indicators/intraday_momentum_index"
+require "ruby_technical_analysis/indicators/macd"
+require "ruby_technical_analysis/indicators/mass_index"
+require "ruby_technical_analysis/indicators/moving_averages"
+require "ruby_technical_analysis/indicators/pivot_points"
+require "ruby_technical_analysis/indicators/price_channel"
+require "ruby_technical_analysis/indicators/qstick"
+require "ruby_technical_analysis/indicators/rate_of_change"
+require "ruby_technical_analysis/indicators/relative_momentum_index"
+require "ruby_technical_analysis/indicators/relative_strength_index"
+require "ruby_technical_analysis/indicators/statistical_methods"
+require "ruby_technical_analysis/indicators/stochastic_oscillator"
+require "ruby_technical_analysis/indicators/volume_oscillator"
+require "ruby_technical_analysis/indicators/volume_rate_of_change"
+require "ruby_technical_analysis/indicators/wilders_smoothing"
+require "ruby_technical_analysis/indicators/williams_percent_r"