indicator_hub 0.1.0

data/lib/indicator_hub/indicators/mfi.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Money Flow Index (MFI).
+    # MFI is a technical oscillator that uses price and volume for identifying
+    # overbought or oversold signals in an asset.
+    class MFI
+      # Calculates the Money Flow Index.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The MFI period (default: 14).
+      # @return [Array<Float, nil>] The calculated MFI values.
+      def self.calculate(data, period: 14)
+        return Array.new(data.size, nil) if data.size <= period
+
+        output = []
+        typical_prices = []
+        raw_money_flows = []
+
+        data.each_with_index do |v, i|
+          typical_price = (v[:high] + v[:low] + v[:close]) / 3.0
+          typical_prices << typical_price
+
+          if i.zero?
+            raw_money_flows << 0.0
+            output << nil
+            next
+          end
+
+          money_flow = typical_price * v[:volume]
+          raw_money_flows << if typical_price > typical_prices[i - 1]
+                               money_flow
+                             elsif typical_price < typical_prices[i - 1]
+                               -money_flow
+                             else
+                               0.0
+                             end
+
+          if raw_money_flows.size > period
+            current_flows = raw_money_flows.last(period)
+            pos_flow = current_flows.select(&:positive?).sum
+            neg_flow = current_flows.select(&:negative?).sum.abs
+
+            if neg_flow.zero?
+              mfi = 100.0
+            else
+              mfr = pos_flow / neg_flow
+              mfi = 100.0 - (100.0 / (1.0 + mfr))
+            end
+            output << mfi
+          else
+            output << nil
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/mi.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Mass Index (MI).
+    # MI is a technical indicator used to predict trend reversals by analyzing
+    # the narrowing and widening of the trading range.
+    class MI
+      # Calculates the Mass Index.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param ema_period [Integer] The EMA period (default: 9).
+      # @param period [Integer] The summation period (default: 25).
+      # @return [Array<Float, nil>] The calculated MI values.
+      def self.calculate(data, ema_period: 9, period: 25)
+        high_low_diffs = data.map do |v|
+          if v.is_a?(Hash)
+            ((v[:high] || v["high"]).to_f - (v[:low] || v["low"]).to_f)
+          else
+            0.0
+          end
+        end
+
+        # First EMA
+        single_ema_values = calculate_ema(high_low_diffs, ema_period)
+
+        # Second EMA (EMA of the first EMA)
+        valid_single_emas = single_ema_values.compact
+        if valid_single_emas.size >= ema_period
+          double_ema_valid_values = calculate_ema(valid_single_emas, ema_period)
+          # Re-align double_ema_values with single_ema_values
+          lead_nils = single_ema_values.size - valid_single_emas.size
+          double_ema_values = Array.new(lead_nils, nil) + double_ema_valid_values
+        else
+          double_ema_values = Array.new(single_ema_values.size, nil)
+        end
+
+        ratios = []
+        single_ema_values.each_with_index do |s_ema, i|
+          d_ema = double_ema_values[i]
+          ratios << (s_ema / d_ema if s_ema && d_ema && d_ema != 0)
+        end
+
+        output = []
+        current_ratios = []
+        ratios.each do |ratio|
+          if ratio.nil?
+            output << nil
+          else
+            current_ratios << ratio
+            current_ratios.shift if current_ratios.size > period
+
+            output << (current_ratios.sum if current_ratios.size == period)
+          end
+        end
+
+        output
+      end
+
+      def self.calculate_ema(data, period)
+        output = []
+        period_values = []
+        previous_ema = nil
+
+        data.each do |v|
+          period_values << v
+          if period_values.size == period
+            ema = CalculationHelpers.ema(v, period_values, period, previous_ema)
+            previous_ema = ema
+            output << ema
+            period_values.shift
+          else
+            output << nil
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/nvi.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Negative Volume Index (NVI).
+    # NVI is a technical indicator used to identify market trends based on
+    # days when volume decreases.
+    class NVI
+      # Calculates the Negative Volume Index.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @return [Array<Float>] The calculated NVI values.
+      def self.calculate(data)
+        nvi_cumulative = 1_000.00
+        output = []
+
+        # We need at least two points to calculate change
+        return [] if data.empty?
+
+        data[0]
+        output << nvi_cumulative # Start with default of 1_000 for the first point
+
+        (1...data.length).each do |i|
+          v = data[i]
+          prev_v = data[i - 1]
+
+          volume_change = ((v[:volume] - prev_v[:volume]) / prev_v[:volume].to_f)
+
+          if volume_change.negative?
+            price_change = (v[:close] - prev_v[:close]) / prev_v[:close].to_f
+            nvi_cumulative *= (1.0 + price_change)
+          end
+
+          output << nvi_cumulative
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/obv.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # On-Balance Volume (OBV).
+    # OBV is a technical momentum indicator that uses volume flow to predict
+    # changes in stock price.
+    class OBV
+      # Calculates the On-Balance Volume.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @return [Array<Float>] The calculated OBV values.
+      def self.calculate(data)
+        current_obv = 0.0
+        output = []
+        return [] if data.empty?
+
+        prior_close = nil
+
+        data.each do |v|
+          volume = v[:volume]
+          close = v[:close]
+
+          unless prior_close.nil?
+            if close > prior_close
+              current_obv += volume
+            elsif close < prior_close
+              current_obv -= volume
+            end
+          end
+
+          output << current_obv
+          prior_close = close
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/obv_mean.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # On-Balance Volume Mean (OBV Mean).
+    # OBV Mean is the average of the On-Balance Volume over a specified period.
+    class OBVMean
+      # Calculates the On-Balance Volume Mean.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The OBV Mean period (default: 10).
+      # @return [Array<Float, nil>] The calculated OBV Mean values.
+      def self.calculate(data, period: 10)
+        current_obv = 0.0
+        obvs = []
+        output = []
+        prior_close = nil
+
+        data.each do |v|
+          volume = v[:volume]
+          close = v[:close]
+
+          unless prior_close.nil?
+            if close > prior_close
+              current_obv += volume
+            elsif close < prior_close
+              current_obv -= volume
+            end
+            obvs << current_obv
+          end
+
+          prior_close = close
+
+          output << (IndicatorHub::CalculationHelpers.average(obvs.last(period)) if obvs.size >= period)
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/pivot_points.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Pivot Points.
+    # Pivot Points are used to identify potential support and resistance levels.
+    class PivotPoints
+      include CalculationHelpers
+
+      # Calculates the Pivot Points.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @return [Array<Hash>] The calculated Pivot Points values { p: Float, s1: Float, s2: Float, s3: Float, r1: Float, r2: Float, r3: Float }.
+      def self.calculate(data)
+        return [] unless data.is_a?(Array) && !data.empty?
+
+        data.map do |bar|
+          high = bar[:high]
+          low = bar[:low]
+          close = bar[:close]
+
+          p = ((high + low + close) / 3.0).round(4)
+
+          s1 = ((2 * p) - high).round(4)
+          s2 = (p - (high - low)).round(4)
+          s3 = (low - (2 * (high - p))).round(4)
+
+          r1 = ((2 * p) - low).round(4)
+          r2 = (p + (high - low)).round(4)
+          r3 = (high + (2 * (p - low))).round(4)
+
+          {
+            p: p,
+            s1: s1,
+            s2: s2,
+            s3: s3,
+            r1: r1,
+            r2: r2,
+            r3: r3
+          }
+        end
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/price_channel.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Price Channel.
+    # Price Channel is a technical indicator that identifies the high and low
+    # prices over a specified period.
+    class PriceChannel
+      include CalculationHelpers
+
+      # Calculates the Price Channel.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The Price Channel period (default: 20).
+      # @return [Array<Hash>] The calculated Price Channel values { upper: Float, lower: Float }.
+      def self.calculate(data, period: 20)
+        return [] if data.length < period
+
+        highs = data.map { |d| d[:high] }
+        lows = data.map { |d| d[:low] }
+
+        results = []
+        (0...data.length).each do |i|
+          if i < period - 1
+            results << { upper: nil, lower: nil }
+          else
+            current_highs = highs[(i - period + 1)..i]
+            current_lows = lows[(i - period + 1)..i]
+            results << {
+              upper: current_highs.max,
+              lower: current_lows.min
+            }
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/qstick.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # QStick.
+    # QStick is a technical indicator that identifies the trend of a security's
+    # price by calculating the moving average of the difference between open and close.
+    class QStick
+      include CalculationHelpers
+
+      # Calculates the QStick.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The QStick period (default: 10).
+      # @return [Array<Float, nil>] The calculated QStick values.
+      def self.calculate(data, period: 10)
+        return [] if data.length < period
+
+        opens = data.map { |d| d[:open] }
+        closes = data.map { |d| d[:close] }
+
+        diffs = closes.zip(opens).map { |c, o| c - o }
+
+        results = []
+        (0...data.length).each do |i|
+          if i < period - 1
+            results << nil
+          else
+            current_diffs = diffs[(i - period + 1)..i]
+            results << (current_diffs.sum.to_f / period).round(4)
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/rmi.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Relative Momentum Index (RMI).
+    # RMI is a variation of the RSI that uses momentum instead of price change.
+    class RMI
+      include CalculationHelpers
+
+      # Calculates the Relative Momentum Index.
+      # @param data [Array<Numeric, Hash>] Array of prices or OHLCV hashes.
+      # @param period [Integer] RMI smoothing period (default: 14).
+      # @param momentum_period [Integer] Momentum period (default: 5).
+      # @return [Array<Float, nil>] The calculated RMI values.
+      def self.calculate(data, period: 14, momentum_period: 5)
+        prices = data.is_a?(Array) && data.first.is_a?(Hash) ? data.map { |d| d[:close] } : data
+        return Array.new(prices.length, nil) if prices.length < momentum_period + period
+
+        ups = []
+        downs = []
+
+        # Calculate momentum changes
+        (momentum_period...prices.length).each do |i|
+          change = prices[i] - prices[i - momentum_period]
+          ups << (change.positive? ? change : 0)
+          downs << (change.negative? ? change.abs : 0)
+        end
+
+        # Wilder's smoothing on ups and downs
+        avg_ups = WildersSmoothing.calculate(ups, period: period)
+        avg_downs = WildersSmoothing.calculate(downs, period: period)
+
+        results = Array.new(momentum_period, nil)
+        (0...avg_ups.length).each do |i|
+          if avg_ups[i].nil? || avg_downs[i].nil?
+            results << nil
+          elsif avg_downs[i].zero?
+            results << 100.0
+          else
+            rs = avg_ups[i].to_f / avg_downs[i]
+            results << (100.0 - (100.0 / (1.0 + rs))).round(4)
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/roc.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Rate of Change (ROC).
+    # ROC is a momentum oscillator that measures the percentage change in price
+    # between the current price and the price a certain number of periods ago.
+    class ROC
+      include CalculationHelpers
+
+      # Calculates the Rate of Change.
+      # @param prices [Array<Numeric>] Array of prices.
+      # @param period [Integer] The ROC period (default: 12).
+      # @return [Array<Float, nil>] The calculated ROC values.
+      def self.calculate(prices, period: 12)
+        return Array.new(prices.length, nil) if prices.length < period
+
+        results = []
+        (0...prices.length).each do |i|
+          if i < period
+            results << nil
+          else
+            current_price = prices[i]
+            lookback_price = prices[i - period]
+
+            results << if lookback_price.zero?
+                         0.0
+                       else
+                         (((current_price - lookback_price).to_f / lookback_price) * 100).round(4)
+                       end
+          end
+        end
+        results
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/rsi.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Relative Strength Index (RSI).
+    # RSI is a momentum oscillator that measures the speed and change of price movements.
+    # It oscillates between 0 and 100. Traditionally, RSI is considered overbought when
+    # above 70 and oversold when below 30.
+    class RSI
+      # Calculates the Relative Strength Index.
+      # @param data [Array<Numeric>] The input data points.
+      # @param period [Integer] The RSI period (default: 14).
+      # @return [Array<Float, nil>] The calculated RSI values.
+      def self.calculate(data, period: 14)
+        return [] if data.size < period
+
+        output = []
+        gains = []
+        losses = []
+        prev_price = data.first
+
+        avg_gain = nil
+        avg_loss = nil
+
+        data.each_with_index do |price, index|
+          if index.zero?
+            output << nil
+            next
+          end
+
+          change = price - prev_price
+          gains << (change.positive? ? change : 0.0)
+          losses << (change.negative? ? change.abs : 0.0)
+
+          if gains.size == period
+            if avg_gain.nil?
+              # Initial average gain/loss is SMA
+              avg_gain = CalculationHelpers.average(gains)
+              avg_loss = CalculationHelpers.average(losses)
+            else
+              # Subsequent use Wilder's Smoothing
+              avg_gain = CalculationHelpers.wilder_smoothing(avg_gain, gains.last, period)
+              avg_loss = CalculationHelpers.wilder_smoothing(avg_loss, losses.last, period)
+            end
+
+            if avg_loss.zero?
+              rsi = avg_gain.zero? ? 0.0 : 100.0
+            else
+              rs = avg_gain / avg_loss
+              rsi = 100.0 - (100.0 / (1.0 + rs))
+            end
+            output << rsi
+            gains.shift
+            losses.shift
+          else
+            output << nil
+          end
+
+          prev_price = price
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/sma.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base_indicator"
+
+module IndicatorHub
+  module Indicators
+    # Simple Moving Average (SMA).
+    # SMA is a basic technical indicator that calculates the average price over a
+    # specified number of periods.
+    class SMA < BaseIndicator
+      # Calculates the Simple Moving Average.
+      # @return [Array<Float, nil>] The calculated SMA values.
+      def calculate
+        period = options[:period] || 20
+        CalculationHelpers.sma(numeric_data, period)
+      end
+
+      # Defines the list of valid option keys for this indicator.
+      # @return [Array<Symbol>]
+      def self.valid_options
+        %i[field period]
+      end
+
+      # Defines the minimum number of data points required for calculation.
+      # @param options [Hash] The current indicator options.
+      # @return [Integer]
+      def self.min_data_size(options)
+        options[:period] || 20
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/so.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Stochastic Oscillator (SO).
+    # SO is a momentum indicator comparing a particular closing price of a
+    # security to a range of its prices over a certain period of time.
+    class SO
+      include CalculationHelpers
+
+      # Calculates the Stochastic Oscillator.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param k_period [Integer] Period for %K calculation (default: 14).
+      # @param k_slowing [Integer] Smoothing for %K (default: 3).
+      # @param d_period [Integer] Period for %D calculation (default: 3).
+      # @return [Array<Hash>] The calculated SO values { k: Float, d: Float }.
+      def self.calculate(data, k_period: 14, k_slowing: 3, d_period: 3)
+        highs = data.map { |d| d[:high] }
+        lows = data.map { |d| d[:low] }
+        closes = data.map { |d| d[:close] }
+
+        fast_ks = []
+        data.each_with_index do |_, i|
+          if i < k_period - 1
+            fast_ks << nil
+          else
+            current_highs = highs[(i - k_period + 1)..i]
+            current_lows = lows[(i - k_period + 1)..i]
+
+            hh = current_highs.max
+            ll = current_lows.min
+
+            fast_ks << if hh == ll
+                         100.0
+                       else
+                         ((closes[i] - ll) / (hh - ll) * 100.0)
+                       end
+          end
+        end
+
+        # Slow %K is SMA of fast %K
+        slow_ks = []
+        if k_slowing > 1
+          fast_ks.each_with_index do |_, i|
+            if i < (k_period - 1) + (k_slowing - 1)
+              slow_ks << nil
+            else
+              period_values = fast_ks[(i - k_slowing + 1)..i]
+              slow_ks << (period_values.sum / k_slowing.to_f)
+            end
+          end
+        else
+          slow_ks = fast_ks
+        end
+
+        # %D is SMA of slow %K
+        ds = []
+        slow_ks.each_with_index do |_, i|
+          if i < (k_period - 1) + (k_slowing > 1 ? (k_slowing - 1) : 0) + (d_period - 1)
+            ds << nil
+          else
+            period_values = slow_ks[(i - d_period + 1)..i]
+            ds << (period_values.sum / d_period.to_f)
+          end
+        end
+
+        data.map.with_index do |_, i|
+          {
+            k: slow_ks[i]&.round(4),
+            d: ds[i]&.round(4)
+          }
+        end
+      end
+    end
+  end
+end