indicator_hub 0.1.0

data/lib/indicator_hub/indicators/cmo.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Chande Momentum Oscillator (CMO).
+    # CMO is a technical momentum indicator developed by Tushar Chande.
+    class CMO
+      # Calculates the Chande Momentum Oscillator.
+      # @param data [Array<Numeric>] Input data.
+      # @param period [Integer] Period for CMO calculation.
+      # @return [Array<Float, nil>]
+      def self.calculate(data, period: 14)
+        output = []
+
+        data.each_with_index do |_val, i|
+          if i < period
+            output << nil
+            next
+          end
+
+          up_sum = 0.0
+          down_sum = 0.0
+
+          (1..period).each do |j|
+            curr = data[i - period + j]
+            prev = data[i - period + j - 1]
+            diff = curr - prev
+            if diff.positive?
+              up_sum += diff
+            else
+              down_sum += diff.abs
+            end
+          end
+
+          if (up_sum + down_sum).zero?
+            output << 0.0
+          else
+            cmo = 100.0 * (up_sum - down_sum) / (up_sum + down_sum)
+            output << cmo
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/cr.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Cumulative Return (CR).
+    # CR is a measure of the total return on an investment over a set period of time.
+    class CR
+      # Calculates the Cumulative Return.
+      # @param data [Array<Numeric>] The input data points.
+      # @param period [Integer] The period (default: 1).
+      # @return [Array<Float>] The calculated CR values.
+      def self.calculate(data, period: 1) # rubocop:disable Lint/UnusedMethodArgument
+        return [] if data.empty?
+
+        start_price = data.first.to_f
+        return Array.new(data.size, 0.0) if start_price.zero?
+
+        data.map do |v|
+          (v.to_f - start_price) / start_price
+        end
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/dc.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Donchian Channel (DC).
+    # DC consists of three lines generated by moving average calculations that comprise
+    # an indicator formed by upper and lower bands around a midrange or median band.
+    class DC
+      # Calculates the Donchian Channel.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The DC period (default: 20).
+      # @return [Array<Hash>] The calculated DC values { upper: Float, middle: Float, lower: Float }.
+      def self.calculate(data, period: 20)
+        output = []
+
+        data.each_with_index do |_, i|
+          if i < period - 1
+            output << { upper: nil, middle: nil, lower: nil }
+          else
+            period_data = data[(i - period + 1)..i]
+            highs = period_data.map { |v| (v[:high] || v["high"]).to_f }
+            lows = period_data.map { |v| (v[:low] || v["low"]).to_f }
+
+            upper = highs.max
+            lower = lows.min
+
+            output << {
+              upper: upper,
+              middle: (upper + lower) / 2.0,
+              lower: lower
+            }
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/dlr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Daily Log Return (DLR).
+    # DLR is the logarithmic return of a security's price from one day to the next.
+    class DLR
+      # Calculates the Daily Log Return.
+      # @param data [Array<Numeric>] The input data points.
+      # @return [Array<Float, nil>] The calculated DLR values.
+      def self.calculate(data)
+        output = []
+        prev_price = nil
+
+        data.each do |v|
+          output << if prev_price.nil?
+                      nil
+                    else
+                      Math.log(v.to_f / prev_price)
+                    end
+          prev_price = v
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/dpo.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Detrended Price Oscillator (DPO).
+    # DPO is an indicator that attempts to eliminate trend from price in order to
+    # make it easier to identify cycles.
+    class DPO
+      # Calculates the Detrended Price Oscillator.
+      # @param data [Array<Numeric>] The input data points.
+      # @param period [Integer] The DPO period (default: 20).
+      # @return [Array<Float, nil>] The calculated DPO values.
+      def self.calculate(data, period: 20)
+        output = []
+        midpoint = (period / 2) + 1
+
+        data.each_with_index do |v, i|
+          if i < (period + midpoint - 2)
+            output << nil
+          else
+            sma_range = data[(i - midpoint - period + 2)..(i - midpoint + 1)]
+            sma = CalculationHelpers.average(sma_range)
+            output << (v - sma)
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/dr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module IndicatorHub
+  module Indicators
+    # Daily Return (DR).
+    # DR is the percentage change in price from one day to the next.
+    class DR
+      # Calculates the Daily Return.
+      # @param data [Array<Numeric>] The input data points.
+      # @return [Array<Float, nil>] The calculated DR values.
+      def self.calculate(data)
+        output = []
+        prev_price = nil
+
+        data.each do |v|
+          output << if prev_price.nil?
+                      nil
+                    else
+                      (v.to_f / prev_price) - 1.0
+                    end
+          prev_price = v
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/ema.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Exponential Moving Average (EMA).
+    # EMA is a type of moving average that places a greater weight and significance
+    # on the most recent data points.
+    class EMA
+      # Calculates the Exponential Moving Average.
+      # @param data [Array<Numeric>] The input data points.
+      # @param period [Integer] The EMA period (default: 20).
+      # @return [Array<Float, nil>] The calculated EMA values.
+      def self.calculate(data, period: 20)
+        period = period.to_i
+        Validation.validate_numeric_data(data)
+        return Array.new(data.size, nil) if data.size < period
+
+        period_values = []
+        previous_ema = nil
+        output = []
+
+        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/envelopes_ema.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "ema"
+
+module IndicatorHub
+  module Indicators
+    # Envelopes EMA.
+    # Envelopes consist of an EMA and two lines plotted at a percentage distance
+    # above and below the EMA.
+    class EnvelopesEMA
+      # Calculates the Envelopes EMA.
+      # @param data [Array<Numeric>] The input data points.
+      # @param period [Integer] The EMA period (default: 20).
+      # @param percentage [Numeric] The percentage distance (default: 5).
+      # @return [Array<Hash>] The calculated Envelopes EMA values { upper: Float, middle: Float, lower: Float }.
+      def self.calculate(data, period: 20, percentage: 5)
+        # Ensure we're working with numbers, if not, something upstream went wrong,
+        # but EMA.calculate will catch it if it expects only numbers.
+        ema_values = EMA.calculate(data, period: period)
+
+        output = []
+        ema_values.each do |ema|
+          if ema.nil?
+            output << { upper: nil, middle: nil, lower: nil }
+          else
+            upper = ema * (1 + (percentage / 100.0))
+            lower = ema * (1 - (percentage / 100.0))
+            output << { upper: upper, middle: ema, lower: lower }
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/eom.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Ease of Movement (EOM).
+    # EOM is a momentum oscillator that emphasizes the relationship between
+    # price change and volume.
+    class EOM
+      # Calculates the Ease of Movement.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The EOM period (default: 14).
+      # @return [Array<Float, nil>] The calculated EOM values.
+      def self.calculate(data, period: 14)
+        output = []
+        emv_values = []
+        prev_v = nil
+
+        data.each do |v|
+          if prev_v.nil?
+            output << nil
+            prev_v = v
+            next
+          end
+
+          distance_moved = ((v[:high] + v[:low]) / 2.0) - ((prev_v[:high] + prev_v[:low]) / 2.0)
+
+          range = (v[:high] - v[:low])
+          box_ratio = range.zero? ? 0 : (v[:volume] / 100_000_000.0) / range
+
+          emv = box_ratio.zero? ? 0 : distance_moved / box_ratio
+          emv_values << emv
+
+          if emv_values.size == period
+            output << CalculationHelpers.average(emv_values)
+            emv_values.shift
+          else
+            output << nil
+          end
+
+          prev_v = v
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/fi.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "ema"
+
+module IndicatorHub
+  module Indicators
+    # Force Index (FI).
+    # FI is an oscillator that uses price and volume to assess the power behind
+    # a move and identify potential turning points.
+    class FI
+      # Calculates the Force Index.
+      # @param data [Array<Numeric, Hash>] Array of prices or OHLCV hashes.
+      # @param period [Integer] The FI period (default: 13).
+      # @return [Array<Float, nil>] The calculated FI values.
+      def self.calculate(data, period: 13)
+        return [] if data.empty?
+
+        raw_fi = []
+        prev_close = nil
+
+        data.each do |v|
+          if v.is_a?(Hash)
+            close = (v[:close] || v["close"]).to_f
+            volume = (v[:volume] || v["volume"]).to_f
+          else
+            close = v.to_f
+            volume = 1.0
+          end
+
+          if prev_close.nil?
+            # First data point has no previous close to calculate force index
+          else
+            raw_fi << ((close - prev_close) * volume)
+          end
+          prev_close = close
+        end
+
+        return Array.new(data.size, nil) if raw_fi.empty?
+
+        ema_fi = EMA.calculate(raw_fi, period: period)
+        [nil] + ema_fi
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/ichimoku.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Ichimoku Cloud.
+    # The Ichimoku Cloud is a collection of technical indicators that show
+    # support and resistance levels, as well as momentum and trend direction.
+    class Ichimoku
+      # Calculates the Ichimoku Cloud components.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param low_period [Integer] Tenkan-sen period (default: 9).
+      # @param medium_period [Integer] Kijun-sen period (default: 26).
+      # @param high_period [Integer] Senkou Span B period (default: 52).
+      # @return [Array<Hash, nil>] The calculated Ichimoku components.
+      def self.calculate(data, low_period: 9, medium_period: 26, high_period: 52)
+        # Expects array of hashes with :high, :low, :close
+        output = []
+
+        data.each_with_index do |_, index|
+          if index < high_period + medium_period - 2
+            output << nil
+            next
+          end
+
+          tenkan_sen = calculate_midpoint(index, low_period, data)
+          kijun_sen = calculate_midpoint(index, medium_period, data)
+          senkou_span_a = calculate_senkou_span_a(index, low_period, medium_period, data)
+          senkou_span_b = calculate_senkou_span_b(index, medium_period, high_period, data)
+          chikou_span = calculate_chikou_span(index, medium_period, data)
+
+          output << {
+            tenkan_sen: tenkan_sen,
+            kijun_sen: kijun_sen,
+            senkou_span_a: senkou_span_a,
+            senkou_span_b: senkou_span_b,
+            chikou_span: chikou_span
+          }
+        end
+        output
+      end
+
+      def self.calculate_midpoint(index, period, data)
+        start_idx = [0, index - period + 1].max
+        period_data = data[start_idx..index]
+        highs = period_data.map { |d| d[:high] }
+        lows = period_data.map { |d| d[:low] }
+        (highs.max + lows.min) / 2.0
+      end
+
+      def self.calculate_senkou_span_a(index, low_period, medium_period, data)
+        mp_ago_index = index - (medium_period - 1)
+        return nil if mp_ago_index.negative?
+
+        t_sen = calculate_midpoint(mp_ago_index, low_period, data)
+        k_sen = calculate_midpoint(mp_ago_index, medium_period, data)
+        (t_sen + k_sen) / 2.0
+      end
+
+      def self.calculate_senkou_span_b(index, medium_period, high_period, data)
+        mp_ago_index = index - (medium_period - 1)
+        return nil if mp_ago_index.negative?
+
+        calculate_midpoint(mp_ago_index, high_period, data)
+      end
+
+      def self.calculate_chikou_span(index, medium_period, data)
+        mp_ago_index = index - (medium_period - 1)
+        return nil if mp_ago_index.negative?
+
+        data[mp_ago_index][:close]
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/imi.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Intraday Momentum Index (IMI).
+    # IMI is a technical indicator that combines candlestick analysis with
+    # the Relative Strength Index (RSI).
+    class IMI
+      # Calculates the Intraday Momentum Index.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The IMI period (default: 14).
+      # @return [Array<Float, nil>] The calculated IMI values.
+      def self.calculate(data, period: 14)
+        output = []
+
+        data.each_with_index do |_val, i|
+          if i < period - 1
+            output << nil
+            next
+          end
+
+          slice = data[(i - period + 1)..i]
+          gsum = 0.0
+          lsum = 0.0
+
+          slice.each do |d|
+            if d[:close] > d[:open]
+              gsum += (d[:close] - d[:open])
+            elsif d[:close] < d[:open]
+              lsum += (d[:open] - d[:close])
+            end
+          end
+
+          if (gsum + lsum).zero?
+            output << 0.0
+          else
+            imi = 100.0 * gsum / (gsum + lsum)
+            output << imi
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/kc.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+
+module IndicatorHub
+  module Indicators
+    # Keltner Channel (KC).
+    # KC is a volatility-based technical indicator composed of three separate lines.
+    class KC
+      # Calculates the Keltner Channel.
+      # @param data [Array<Hash>] Array of OHLCV hashes.
+      # @param period [Integer] The KC period (default: 20).
+      # @param multiplier [Float] The ATR multiplier (default: 1.5).
+      # @return [Array<Hash, nil>] The calculated KC values { upper: Float, middle: Float, lower: Float }.
+      def self.calculate(data, period: 20, multiplier: 1.5)
+        output = []
+        typical_prices = []
+        trading_ranges = []
+
+        data.each do |v|
+          tp = (v[:high] + v[:low] + v[:close]) / 3.0
+          tr = v[:high] - v[:low]
+
+          typical_prices << tp
+          trading_ranges << tr
+
+          if typical_prices.size == period
+            mb = CalculationHelpers.average(typical_prices)
+            tra = CalculationHelpers.average(trading_ranges)
+
+            output << {
+              upper: mb + (tra * multiplier),
+              middle: mb,
+              lower: mb - (tra * multiplier)
+            }
+            typical_prices.shift
+            trading_ranges.shift
+          else
+            output << nil
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/indicator_hub/indicators/kst.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../calculation_helpers"
+require_relative "sma"
+
+module IndicatorHub
+  module Indicators
+    # Know Sure Thing (KST).
+    # KST is a momentum oscillator based on the smoothed rate-of-change of four
+    # different timeframes.
+    class KST
+      # Calculates the Know Sure Thing.
+      # @param data [Array<Numeric, Hash>] Array of prices or OHLCV hashes.
+      # @param r1 [Integer] ROC period 1 (default: 10).
+      # @param r2 [Integer] ROC period 2 (default: 15).
+      # @param r3 [Integer] ROC period 3 (default: 20).
+      # @param r4 [Integer] ROC period 4 (default: 30).
+      # @param s1 [Integer] SMA period 1 (default: 10).
+      # @param s2 [Integer] SMA period 2 (default: 10).
+      # @param s3 [Integer] SMA period 3 (default: 10).
+      # @param s4 [Integer] SMA period 4 (default: 15).
+      # @param signal [Integer] Signal line period (default: 9).
+      # @return [Array<Hash>] The calculated KST values { kst: Float, signal: Float }.
+      def self.calculate(data, r1: 10, r2: 15, r3: 20, r4: 30, s1: 10, s2: 10, s3: 10, s4: 15, signal: 9)
+        # Use close prices for KST
+        closes = data.map do |v|
+          if v.is_a?(Hash)
+            (v[:close] || v["close"]).to_f
+          else
+            v.to_f
+          end
+        end
+
+        kst_values = []
+        closes.each_with_index do |_, i|
+          rcma1 = calculate_rcma(closes, i, r1, s1)
+          rcma2 = calculate_rcma(closes, i, r2, s2)
+          rcma3 = calculate_rcma(closes, i, r3, s3)
+          rcma4 = calculate_rcma(closes, i, r4, s4)
+
+          if rcma1 && rcma2 && rcma3 && rcma4
+            kst = (1.0 * rcma1) + (2.0 * rcma2) + (3.0 * rcma3) + (4.0 * rcma4)
+            kst_values << kst
+          else
+            kst_values << nil
+          end
+        end
+
+        # Calculate signal line (SMA of KST)
+        valid_kst = kst_values.compact
+        if valid_kst.size >= signal
+          signal_line_valid = CalculationHelpers.sma(valid_kst, signal)
+          lead_nils_count = kst_values.count(nil)
+          full_signal_line = Array.new(lead_nils_count, nil) + signal_line_valid
+        else
+          full_signal_line = Array.new(kst_values.size, nil)
+        end
+
+        kst_values.zip(full_signal_line).map do |kst, sig|
+          { kst: kst, signal: sig }
+        end
+      end
+
+      def self.calculate_rcma(data, index, roc, sma)
+        # ROC = (Price(t) - Price(t-roc)) / Price(t-roc) * 100
+        # RCMA = SMA of ROC over 'sma' periods
+        return nil if index < (roc + sma)
+
+        roc_data = []
+        ((index - sma + 1)..index).each do |i|
+          current_price = data[i]
+          past_price = data[i - roc]
+          return nil if past_price.nil? || past_price.zero?
+
+          roc_data << ((current_price - past_price) / past_price.to_f * 100.0)
+        end
+        CalculationHelpers.average(roc_data)
+      end
+      private_class_method :calculate_rcma
+    end
+  end
+end

data/lib/indicator_hub/indicators/macd.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "ema"
+
+module IndicatorHub
+  module Indicators
+    # Moving Average Convergence Divergence (MACD).
+    # MACD is a trend-following momentum indicator that shows the relationship
+    # between two moving averages of a security’s price.
+    class MACD
+      # Calculates the Moving Average Convergence Divergence.
+      # @param data [Array<Numeric>] The input data points.
+      # @param fast_period [Integer] The fast EMA period (default: 12).
+      # @param slow_period [Integer] The slow EMA period (default: 26).
+      # @param signal_period [Integer] The signal EMA period (default: 9).
+      # @return [Array<Hash, nil>] The calculated MACD components (macd, signal, histogram).
+      def self.calculate(data, fast_period: 12, slow_period: 26, signal_period: 9)
+        fast_ema = EMA.calculate(data, period: fast_period)
+        slow_ema = EMA.calculate(data, period: slow_period)
+
+        macd_line = []
+        data.each_with_index do |_, i|
+          macd_line << (fast_ema[i] - slow_ema[i] if fast_ema[i] && slow_ema[i])
+        end
+
+        # Signal Line is EMA of MACD line (ignoring initial nil values)
+        compact_macd = macd_line.compact
+        compact_signal = EMA.calculate(compact_macd, period: signal_period)
+
+        # Re-align signal line with original data
+        signal_line = Array.new(macd_line.size - compact_signal.size, nil) + compact_signal
+
+        output = []
+        data.each_with_index do |_, i|
+          histogram = macd_line[i] && signal_line[i] ? (macd_line[i] - signal_line[i]) : nil
+          output << {
+            macd: macd_line[i],
+            signal: signal_line[i],
+            histogram: histogram
+          }
+        end
+        output
+      end
+    end
+  end
+end