quantitative 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cfda18120bf7e3432b359a53d19d633f70f66e3ea4468098673cfc89ac2f77e
-  data.tar.gz: 598dc565f6da96ce9565afee249f38bc909234177d7b484ce82cba226e2e8d60
+  metadata.gz: 8908c3b863d42be9e0c27fcce1dc57a7b0f0b2f4699cb559140eca1caa717223
+  data.tar.gz: 2fda3094ef0da147ed1aef5c5aa6b3020f3de426e885562dab714ed00d3bac43
 SHA512:
-  metadata.gz: 5b2625954abe0e72a776de95da8d26af213440cb7e2d7beddd48529dfdb70d7247562066b09a3edd1dd3f171ad3ff8a32390ffe337729ca9712f65bdb147084e
-  data.tar.gz: 780f81a808f14d2d63b53aa81f8f30920b252979f17409d1ba48105ed5eadc91dadc253ada0cd75c6c21b8e6a8450cf39c75ce542adb450759fb097679899cce
+  metadata.gz: a35fa3205f447fa5b43a52c7725b3ee3fe3c576c5663e2a5cb29fb67325ca11ee4bea24e80bc93510f7d0c22c5bce706fb809a0e8b9a73bfe00a831f28e875ca
+  data.tar.gz: 1f31136c06beacee9276208a2e9a6bdaebd4c60930ece409b552581dea19b27e38231680ab7699e985cf1040b12d4ac0819510bc748c364051033b3bcd0e4017

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.3.1)
+    quantitative (0.3.2)
       oj (~> 3.10)
       zeitwerk (~> 2.6)
 

data/lib/quant/dominant_cycles_source.rb

@@ -17,40 +17,9 @@ module Quant
   class DominantCyclesSource
     def initialize(indicator_source:)
       @indicator_source = indicator_source
+      indicator_source.define_indicator_accessors(indicator_source: self)
     end
 
-    # Auto-Correlation Reversals is a method of computing the dominant cycle
-    # by correlating the data stream with itself delayed by a lag.
-    def acr; indicator(Indicators::DominantCycles::Acr) end
-
-    # The band-pass dominant cycle passes signals within a certain frequency
-    # range, and attenuates signals outside that range.
-    # The trend component of the signal is removed, leaving only the cyclical
-    # component.  Then we count number of iterations between zero crossings
-    # and this is the `period` of the dominant cycle.
-    def band_pass; indicator(Indicators::DominantCycles::BandPass) end
-
-    # The Dual Differentiator algorithm computes the phase angle from the
-    # analytic signal as the arctangent of the ratio of the imaginary
-    # component to the real component. Further, the angular frequency
-    # is defined as the rate change of phase. We can use these facts to
-    # derive the cycle period.
-    def differential; indicator(Indicators::DominantCycles::Differential) end
-
-    # Static, arbitrarily set period.
-    def half_period; indicator(Indicators::DominantCycles::HalfPeriod) end
-
-    # Homodyne means the signal is multiplied by itself. More precisely,
-    # we want to multiply the signal of the current bar with the complex
-    # value of the signal one bar ago
-    def homodyne; indicator(Indicators::DominantCycles::Homodyne) end
-
-    # The phase accumulation method of computing the dominant cycle measures
-    # the phase at each sample by taking the arctangent of the ratio of the
-    # quadrature component to the in-phase component.  The phase is then
-    # accumulated and the period is derived from the phase.
-    def phase_accumulator; indicator(Indicators::DominantCycles::PhaseAccumulator) end
-
     private
 
     def indicator(indicator_class)

data/lib/quant/indicators/adx.rb

@@ -21,12 +21,9 @@ module Quant
     end
 
     class Adx < Indicator
+      register name: :adx
       depends_on Indicators::Atr
 
-      def alpha
-        bars_to_alpha(dc_period)
-      end
-
       def scale
         1.0
       end
@@ -71,7 +68,7 @@ module Quant
         p0.di_ema = three_pole_super_smooth(:di, period:, previous: :di_ema).clamp(-10.0, 10.0)
 
         p0.value = p0.di_ema
-        p0.inst_stoch = stochastic :di, period: dc_period
+        p0.inst_stoch = stochastic(:di, period:)
         p0.stoch = three_pole_super_smooth :inst_stoch, period:, previous: :stoch
       end
     end

data/lib/quant/indicators/atr.rb

@@ -25,6 +25,8 @@ module Quant
     end
 
     class Atr < Indicator
+      register name: :atr
+
       attr_reader :points
 
       def period

data/lib/quant/indicators/cci.rb

@@ -18,6 +18,8 @@ module Quant
     #
     # SOURCE: https://www.mesasoftware.com/papers/CORRELATION%20AS%20A%20CYCLE%20INDICATOR.pdf
     class Cci < Indicator
+      register name: :cci
+
       def max_period
         [min_period, dc_period].max
       end

data/lib/quant/indicators/decycler.rb

@@ -24,6 +24,8 @@ module Quant
     end
 
     class Decycler < Indicator
+      register name: :decycler
+
       def max_period
         dc_period
       end

data/lib/quant/indicators/dominant_cycles/acr.rb

@@ -28,6 +28,8 @@ module Quant
       # The cyclic information is extracted using a discrete Fourier transform
       # (DFT) of the autocorrelation results.
       class Acr < DominantCycle
+        register name: :acr
+
         BANDWIDTH_DEGREES = 370
         BANDWIDTH_RADIANS = BANDWIDTH_DEGREES * Math::PI / 180.0
 

data/lib/quant/indicators/dominant_cycles/band_pass.rb

@@ -20,6 +20,8 @@ module Quant
       # component.  Then we count number of iterations between zero crossings
       # and this is the `period` of the dominant cycle.
       class BandPass < DominantCycle
+        register name: :band_pass
+
         def bandwidth
           0.75
         end

data/lib/quant/indicators/dominant_cycles/differential.rb

@@ -9,6 +9,8 @@ module Quant
       # is defined as the rate change of phase. We can use these facts to
       # derive the cycle period.
       class Differential < DominantCycle
+        register name: :differential
+
         def compute_period
           p0.ddd = (p0.q2 * (p0.i2 - p1.i2)) - (p0.i2 * (p0.q2 - p1.q2))
           p0.inst_period = p0.ddd > 0.01 ? 6.2832 * (p0.i2**2 + p0.q2**2) / p0.ddd : 0.0

data/lib/quant/indicators/dominant_cycles/half_period.rb

@@ -12,6 +12,8 @@ module Quant
       end
 
       class HalfPeriod < DominantCycle
+        register name: :half_period
+
         def compute
           # No-Op
         end

data/lib/quant/indicators/dominant_cycles/homodyne.rb

@@ -7,6 +7,8 @@ module Quant
       # we want to multiply the signal of the current bar with the complex
       # value of the signal one bar ago
       class Homodyne < DominantCycle
+        register name: :homodyne
+
         def compute_period
           p0.re = (p0.i2 * p1.i2) + (p0.q2 * p1.q2)
           p0.im = (p0.i2 * p1.q2) - (p0.q2 * p1.i2)

data/lib/quant/indicators/dominant_cycles/phase_accumulator.rb

@@ -24,6 +24,8 @@ module Quant
       # Therefore, shorter cycle periods necessarily have a higher output
       # signal-to-noise ratio.
       class PhaseAccumulator < DominantCycle
+        register name: :phase_accumulator
+
         def compute_period
           p0.i1 = 0.15 * p0.i1 + 0.85 * p1.i1
           p0.q1 = 0.15 * p0.q1 + 0.85 * p1.q1

data/lib/quant/indicators/ema.rb

@@ -0,0 +1,67 @@
+module Quant
+  module Indicators
+    class EmaPoint < IndicatorPoint
+      attribute :ss_dc_period, default: :input
+      attribute :ss_half_dc_period, default: :input
+      attribute :ss_micro_period, default: :input
+      attribute :ss_min_period, default: :input
+      attribute :ss_half_period, default: :input
+      attribute :ss_max_period, default: :input
+
+      attribute :ema_dc_period, default: :input
+      attribute :ema_half_dc_period, default: :input
+      attribute :ema_micro_period, default: :input
+      attribute :ema_min_period, default: :input
+      attribute :ema_half_period, default: :input
+      attribute :ema_max_period, default: :input
+
+      attribute :osc_dc_period, default: 0.0
+      attribute :osc_half_dc_period, default: 0.0
+      attribute :osc_micro_period, default: 0.0
+      attribute :osc_min_period, default: 0.0
+      attribute :osc_half_period, default: 0.0
+      attribute :osc_max_period, default: 0.0
+    end
+
+    class Ema < Indicator
+      register name: :ema
+
+      def half_dc_period
+        dc_period / 2
+      end
+
+      def compute_super_smoothers
+        p0.ss_dc_period = super_smoother :input, previous: :ss_dc_period, period: dc_period
+        p0.ss_half_dc_period = super_smoother :input, previous: :ss_half_dc_period, period: half_dc_period
+        p0.ss_micro_period = super_smoother :input, previous: :ss_micro_period, period: micro_period
+        p0.ss_min_period = super_smoother :input, previous: :ss_min_period, period: min_period
+        p0.ss_half_period = super_smoother :input, previous: :ss_half_period, period: half_period
+        p0.ss_max_period = super_smoother :input, previous: :ss_max_period, period: max_period
+      end
+
+      def compute_emas
+        p0.ema_dc_period = ema :input, previous: :ema_dc_period, period: dc_period
+        p0.ema_half_dc_period = ema :input, previous: :ema_half_dc_period, period: half_dc_period
+        p0.ema_micro_period = ema :input, previous: :ema_micro_period, period: micro_period
+        p0.ema_min_period = ema :input, previous: :ema_min_period, period: min_period
+        p0.ema_half_period = ema :input, previous: :ema_half_period, period: half_period
+        p0.ema_max_period = ema :input, previous: :ema_max_period, period: max_period
+      end
+
+      def compute_oscillators
+        p0.osc_dc_period = p0.ss_dc_period - p0.ema_dc_period
+        p0.osc_half_dc_period = p0.ss_half_dc_period - p0.ema_half_dc_period
+        p0.osc_micro_period = p0.ss_micro_period - p0.ema_micro_period
+        p0.osc_min_period = p0.ss_min_period - p0.ema_min_period
+        p0.osc_half_period = p0.ss_half_period - p0.ema_half_period
+        p0.osc_max_period = p0.ss_max_period - p0.ema_max_period
+      end
+
+      def compute
+        compute_super_smoothers
+        compute_emas
+        compute_oscillators
+      end
+    end
+  end
+end

data/lib/quant/indicators/frama.rb

@@ -15,6 +15,7 @@ module Quant
     #
     # SOURCE: http://www.mesasoftware.com/papers/FRAMA.pdf
     class Frama < Indicator
+      register name: :frama
       using Quant
 
       # The max_period is divided into two smaller, equal periods, so must be even

data/lib/quant/indicators/indicator.rb

@@ -15,6 +15,10 @@ module Quant
       include Mixins::FisherTransform
       # include Mixins::Direction
 
+      def self.register(name:)
+        Quant::IndicatorsSource.register(name:, indicator_class: self)
+      end
+
       # Provides a registry of dependent indicators for each indicator class.
       # NOTE: Internal use only.
       def self.dependent_indicator_classes

data/lib/quant/indicators/mama.rb

@@ -46,6 +46,8 @@ module Quant
     # dominant cycle indicator other than the homodyne for the rest
     # of your indicators.
     class Mama < Indicator
+      register name: :mama
+
       # constrain between 6 and 50 bars
       def constrain_period_bars
         p0.period = p0.period.clamp(min_period, max_period)

data/lib/quant/indicators/mesa.rb

@@ -33,12 +33,11 @@ module Quant
     # indicators for the dominant cycle, then this version is useful
     # as it avoids extra computational steps.
     class Mesa < Indicator
-      def period
-        dc_period
-      end
+      register name: :mesa
+      depends_on DominantCycles::Homodyne
 
       def fast_limit
-        @fast_limit ||= bars_to_alpha(min_period / 2)
+        @fast_limit ||= bars_to_alpha(micro_period)
       end
 
       def slow_limit

data/lib/quant/indicators/ping.rb

@@ -13,6 +13,8 @@ module Quant
 
     # A simple idicator used primarily to test the indicator system
     class Ping < Indicator
+      register name: :ping
+
       def compute
         p0.pong = input
         p0.compute_count += 1

data/lib/quant/indicators/pivots/atr.rb

@@ -2,6 +2,7 @@ module Quant
   module Indicators
     module Pivots
       class Atr < Pivot
+        register name: :atr
         depends_on Indicators::Atr
 
         def atr_point

data/lib/quant/indicators/pivots/bollinger.rb

@@ -4,6 +4,8 @@ module Quant
   module Indicators
     module Pivots
       class Bollinger < Pivot
+        register name: :bollinger
+
         using Quant
 
         def compute_midpoint

data/lib/quant/indicators/pivots/camarilla.rb

@@ -27,9 +27,7 @@ module Quant
       # S5 = S4 – 1.168 * (S3 – S4)
       # S6 = Close – (R6 – Close)
       class Camarilla < Pivot
-        def multiplier
-          1.1
-        end
+        register name: :camarilla
 
         def compute_midpoint
           p0.midpoint = t0.close_price

data/lib/quant/indicators/pivots/classic.rb

@@ -4,6 +4,8 @@ module Quant
   module Indicators
     module Pivots
       class Classic < Pivot
+        register name: :classic
+
         def compute_midpoint
           p0.midpoint = super_smoother :input, previous: :midpoint, period: averaging_period
         end

data/lib/quant/indicators/pivots/demark.rb

@@ -14,6 +14,8 @@ module Quant
       # PP = X / 4 (this is not an official DeMark number but merely a reference point based on the calculation of X)
       # S1 = X / 2 - H
       class Demark < Pivot
+        register name: :demark
+
         def averaging_period
           min_period / 2
         end

data/lib/quant/indicators/pivots/donchian.rb

@@ -4,6 +4,7 @@ module Quant
   module Indicators
     module Pivots
       class Donchian < Pivot
+        register name: :donchian
         using Quant
 
         def st_period; min_period end

data/lib/quant/indicators/pivots/fibbonacci.rb

@@ -2,6 +2,8 @@ module Quant
   module Indicators
     module Pivots
       class Fibbonacci < Pivot
+        register name: :fibbonacci
+
         def averaging_period
           half_period
         end

data/lib/quant/indicators/pivots/guppy.rb

@@ -2,6 +2,8 @@ module Quant
   module Indicators
     module Pivots
       class Guppy < Pivot
+        register name: :guppy
+
         def guppy_ema(period, band)
           return p0.input unless p1[band]
 
@@ -15,7 +17,7 @@ module Quant
 
         # The short-term MAs are typically set at 3, 5, 8, 10, 12, and 15 periods. The
         # longer-term MAs are typically set at 30, 35, 40, 45, 50, and 60.
-        def compute
+        def compute_bands
           p0[1] = guppy_ema(5,  1)
           p0[2] = guppy_ema(8,  2)
           p0[3] = guppy_ema(10, 3)

data/lib/quant/indicators/pivots/keltner.rb

@@ -2,6 +2,7 @@ module Quant
   module Indicators
     module Pivots
       class Keltner < Pivot
+        register name: :keltner
         depends_on Indicators::Atr
 
         def atr_point

data/lib/quant/indicators/pivots/murrey.rb

@@ -3,6 +3,8 @@ module Quant
   module Indicators
     module Pivots
       class Murrey < Pivot
+        register name: :murrey
+
         def multiplier
           0.125
         end

data/lib/quant/indicators/pivots/pivot.rb

@@ -0,0 +1,109 @@
+module Quant
+  module Indicators
+    module Pivots
+      class PivotPoint < IndicatorPoint
+        attribute :high_price
+        attribute :avg_high, default: :high_price
+        attribute :highest, default: :input
+
+        attribute :low_price
+        attribute :avg_low, default: :low_price
+        attribute :lowest, default: :input
+
+        attribute :range, default: 0.0
+        attribute :avg_range, default: 0.0
+        attribute :std_dev, default: 0.0
+
+        def bands
+          @bands ||= { 0 => input }
+        end
+
+        def [](band)
+          bands[band]
+        end
+
+        def []=(band, value)
+          bands[band] = value
+        end
+
+        def key?(band)
+          bands.key?(band)
+        end
+
+        def midpoint
+          bands[0]
+        end
+        alias :h0 :midpoint
+        alias :l0 :midpoint
+
+        def midpoint=(value)
+          bands[0] = value
+        end
+        alias :h0= :midpoint=
+        alias :l0= :midpoint=
+
+        (1..8).each do |band|
+          define_method("h#{band}") { bands[band] }
+          define_method("h#{band}=") { |value| bands[band] = value }
+
+          define_method("l#{band}") { bands[-band] }
+          define_method("l#{band}=") { |value| bands[-band] = value }
+        end
+      end
+
+      class Pivot < Indicator
+        def points_class
+          Quant::Indicators::Pivots::PivotPoint
+        end
+
+        def band?(band)
+          p0.key?(band)
+        end
+
+        def period
+          dc_period
+        end
+
+        def averaging_period
+          min_period
+        end
+
+        def period_midpoints
+          period_points(period).map(&:midpoint)
+        end
+
+        def compute
+          compute_extents
+          compute_value
+          compute_midpoint
+          compute_bands
+        end
+
+        def compute_midpoint
+          p0.midpoint = p0.input
+        end
+
+        def compute_value
+          # No-op -- override in subclasses
+        end
+
+        def compute_bands
+          # No-op -- override in subclasses
+        end
+
+        def compute_extents
+          period_midpoints.tap do |midpoints|
+            p0.high_price = t0.high_price
+            p0.low_price = t0.low_price
+            p0.highest = midpoints.max
+            p0.lowest = midpoints.min
+            p0.range = p0.high_price - p0.low_price
+            p0.avg_low = super_smoother(:low_price, previous: :avg_low, period: averaging_period)
+            p0.avg_high = super_smoother(:high_price, previous: :avg_high, period: averaging_period)
+            p0.avg_range = super_smoother(:range, previous: :avg_range, period: averaging_period)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/traditional.rb

@@ -2,6 +2,8 @@ module Quant
   module Indicators
     module Pivots
       class Traditional < Pivot
+        register name: :traditional
+
         def multiplier
           2.0
         end

data/lib/quant/indicators/pivots/woodie.rb

@@ -22,6 +22,8 @@ module Quant
       #   S3 = L - 2 * (H - PP) (same as: S1 - RANGE)
       #   S4 = S3 - RANGE
       class Woodie < Pivot
+        register name: :woodie
+
         def compute_value
           p0.input = (t1.high_price + t1.low_price + 2.0 * t0.open_price) / 4.0
         end

data/lib/quant/indicators/rocket_rsi.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class RocketRsiPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+
+      attribute :delta, default: 0.0
+      attribute :gain, default: 0.0
+      attribute :loss, default: 0.0
+
+      attribute :gains, default: 0.0
+      attribute :losses, default: 0.0
+      attribute :denom, default: 0.0
+
+      attribute :inst_rsi, default: 0.5
+      attribute :rsi, default: 0.0
+      attribute :crosses, default: false
+    end
+
+    class RocketRsi < Indicator
+      register name: :rocket_rsi
+
+      def quarter_period
+        half_period / 2
+      end
+
+      def half_period
+        (dc_period / 2) - 1
+      end
+
+      def compute
+        p0.hp = two_pole_butterworth :input, previous: :hp, period: quarter_period
+
+        lp = p(half_period)
+        p0.delta = p0.hp - lp.hp
+        p0.delta > 0.0 ? p0.gain = p0.delta : p0.loss = p0.delta.abs
+
+        period_points(half_period).tap do |period_points|
+          p0.gains = period_points.map(&:gain).sum
+          p0.losses = period_points.map(&:loss).sum
+        end
+
+        p0.denom = p0.gains + p0.losses
+
+        if p0.denom.zero?
+          p0.inst_rsi = p1.inst_rsi
+          p0.rsi = p1.rsi
+        else
+          p0.inst_rsi = ((p0.gains - p0.losses) / p0.denom)
+          p0.rsi = fisher_transform(p0.inst_rsi).clamp(-1.0, 1.0)
+        end
+        p0.crosses = (p0.rsi >= 0.0 && p1.rsi < 0.0) || (p0.rsi <= 0.0 && p1.rsi > 0.0)
+      end
+    end
+  end
+end

data/lib/quant/indicators/roofing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    # The ideal time to buy is when the cycle is at a trough, and the ideal time to exit a long position or to
+    # sell short is when the cycle is at a peak.These conditions are flagged by the filter crossing itself
+    # delayed by two bars, and are included as part of the indicator.
+    class RoofingPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :value, default: 0.0
+      attribute :peak, default: 0.0
+      attribute :agc, default: 0.0
+      attribute :direction, default: 0
+      attribute :turned, default: false
+    end
+
+    class Roofing < Indicator
+      register name: :roofing
+
+      def low_pass_period
+        dc_period
+      end
+
+      def high_pass_period
+        low_pass_period * 2
+      end
+
+      # //Highpass filter cyclic components whose periods are shorter than 48 bars
+      # alpha1 = (Cosine(.707*360 / HPPeriod) + Sine (.707*360 / HPPeriod) - 1) / Cosine(.707*360 / HPPeriod);
+      # HP = (1 - alpha1 / 2)*(1 - alpha1 / 2)*(Close - 2*Close[1] + Close[2]) + 2*(1 - alpha1)*HP[1] - (1 - alpha1)*
+      # (1 - alpha1)*HP[2];
+      # //Smooth with a Super Smoother Filter from equation 3-3
+      # a1 = expvalue(-1.414*3.14159 / LPPeriod);
+      # b1 = 2*a1*Cosine(1.414*180 / LPPeriod);
+      # c2 = b1;
+      # c3 = -a1*a1;
+      # c1 = 1 - c2 - c3;
+      # Filt = c1*(HP + HP[1]) / 2 + c2*Filt[1] + c3*Filt[2
+      def compute
+        a = Math.cos(0.707 * deg2rad(360) / high_pass_period)
+        b = Math.sin(0.707 * deg2rad(360) / high_pass_period)
+        alpha1 = (a + b - 1) / a
+
+        p0.hp = (1 - alpha1 / 2)**2 * (p0.input - 2 * p1.input + p2.input) + 2 * (1 - alpha1) * p1.hp - (1 - alpha1)**2 * p2.hp
+        a1 = Math.exp(-1.414 * Math::PI / low_pass_period)
+        c2 = 2 * a1 * Math.cos(1.414 * deg2rad(180) / low_pass_period)
+        c3 = -a1**2
+        c1 = 1 - c2 - c3
+        p0.value = c1 * (p0.hp + p1.hp) / 2 + c2 * p1.value + c3 * p2.value
+        p0.direction = p0.value > p2.value ? 1 : -1
+        p0.turned = p0.direction != p2.direction
+        # Peak = .991 * Peak[1];
+        # If AbsValue(BP) > Peak Then Peak = AbsValue(BP); If Peak <> 0 Then Signal = BP / Peak;
+        p0.peak = [p0.value.abs, 0.991 * p1.peak].max
+        p0.agc = p0.peak == 0 ? 0 : p0.value / p0.peak
+      end
+    end
+  end
+end

data/lib/quant/indicators/rsi.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class RsiPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :filter, default: 0.0
+
+      attribute :delta, default: 0.0
+      attribute :gain, default: 0.0
+      attribute :loss, default: 0.0
+
+      attribute :gains, default: 0.0
+      attribute :losses, default: 0.0
+      attribute :denom, default: 0.0
+
+      attribute :inst_rsi, default: 0.0
+      attribute :rsi, default: 0.0
+    end
+
+    # The Relative Strength Index (RSI) is a momentum oscillator that measures the
+    # speed and change of price movements.  This RSI indicator is adaptive and
+    # uses the half-period of the dominant cycle to calculate the RSI.
+    # It is further smoothed by an exponential moving average of the last three bars
+    # (or whatever the micro_period is set to).
+    #
+    # The RSI oscillates between 0 and 1.  Traditionally, and in this implementation,
+    # the RSI is considered overbought when above 0.7 and oversold when below 0.3.
+    class Rsi < Indicator
+      register name: :rsi
+
+      def quarter_period
+        half_period / 2
+      end
+
+      def half_period
+        (dc_period / 2) - 1
+      end
+
+      def compute
+        # The High Pass filter is half the dominant cycle period while the
+        # Low Pass Filter (super smoother) is the quarter dominant cycle period.
+        p0.hp = high_pass_filter :input, period: half_period
+        p0.filter = ema :hp, previous: :filter, period: quarter_period
+
+        lp = p(half_period)
+        p0.delta = p0.filter - lp.filter
+        p0.delta > 0.0 ? p0.gain = p0.delta : p0.loss = p0.delta.abs
+
+        period_points(half_period).tap do |period_points|
+          p0.gains = period_points.map(&:gain).sum
+          p0.losses = period_points.map(&:loss).sum
+        end
+
+        p0.denom = p0.gains + p0.losses
+
+        if p0.denom > 0.0
+          p0.inst_rsi = (p0.gains / p0.denom)
+          p0.rsi = ema :inst_rsi, previous: :rsi, period: micro_period
+        else
+          p0.inst_rsi = 0.5
+          p0.rsi = 0.5
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/snr.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class SnrPoint < IndicatorPoint
+      attribute :smooth, default: 0.0
+      attribute :detrend, default: 0.0
+      attribute :i1, default: 0.0
+      attribute :q1, default: 0.0
+      attribute :noise, default: 0.0
+      attribute :signal, default: 0.0
+      attribute :ratio, default: 0.0
+      attribute :state, default: 0
+    end
+
+    class Snr < Indicator
+      register name: :snr
+      depends_on DominantCycles::Homodyne
+
+      def homodyne_dominant_cycle
+        series.indicators[source].dominant_cycles.homodyne
+      end
+
+      def current_dominant_cycle
+        homodyne_dominant_cycle.points[t0]
+      end
+
+      def threshold
+        @threshold ||= 10 * Math.log(0.5)**2
+      end
+
+      def compute_values
+        current_dominant_cycle.tap do |dc|
+          p0.i1 = dc.i1
+          p0.q1 = dc.q1
+        end
+      end
+
+      def compute_noise
+        noise = (p0.input - p2.input).abs
+        p0.noise = p1.noise.zero? ? noise : (0.1 * noise) + (0.9 * p1.noise)
+      end
+
+      def compute_ratio
+        # p0.ratio = 0.25 * (10 * Math.log(p0.i1**2 + p0.q1**2) / Math.log(10)) + 0.75 * p1.ratio
+        # ratio = .25*(10 * Log(I1*I1 + Q1*Q1)/(Range*Range))/Log(10) + 6) + .75*ratio[1]
+        if p0 == p1
+          p0.signal = 0.0
+          p0.ratio = 1.0
+        else
+          p0.signal = threshold + 10.0 * (Math.log((p0.i1**2 + p0.q1**2)/(p0.noise**2)) / Math.log(10))
+          p0.ratio = (0.25 * p0.signal) + (0.75 * p1.ratio)
+        end
+        p0.state = p0.ratio >= threshold ? 1 : 0
+      end
+
+      def compute
+        compute_values
+        compute_noise
+        compute_ratio
+      end
+    end
+  end
+end

data/lib/quant/indicators_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quant
+  module IndicatorsRegistry
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def define_indicator_accessors(indicator_source:)
+      self.class.define_indicator_accessors(indicator_source:)
+    end
+
+    module ClassMethods
+      def registry
+        @registry ||= {}
+      end
+
+      class RegistryEntry
+        attr_reader :name, :indicator_class
+
+        def initialize(name:, indicator_class:)
+          @name = name
+          @indicator_class = indicator_class
+        end
+
+        def key
+          "#{indicator_class.name}::#{name}"
+        end
+
+        def standard?
+          !pivot? && !dominant_cycle?
+        end
+
+        def pivot?
+          indicator_class < Indicators::Pivots::Pivot
+        end
+
+        def dominant_cycle?
+          indicator_class < Indicators::DominantCycles::DominantCycle
+        end
+      end
+
+      def register(name:, indicator_class:)
+        entry = RegistryEntry.new(name:, indicator_class:)
+        registry[entry.key] = entry
+        # registry[name] = indicator_class
+      end
+
+      def registry_entries_for(indicator_source:)
+        return registry.values.select(&:pivot?) if indicator_source.is_a?(PivotsSource)
+        return registry.values.select(&:dominant_cycle?) if indicator_source.is_a?(DominantCyclesSource)
+
+        registry.values.select(&:standard?)
+      end
+
+      def define_indicator_accessors(indicator_source:)
+        registry_entries_for(indicator_source:).each do |entry|
+          indicator_source.define_singleton_method(entry.name) { indicator(entry.indicator_class) }
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators_source.rb

@@ -16,13 +16,18 @@ module Quant
   # By design, the {Quant::Indicators::Indicator} class holds the {Quant::Ticks::Tick} instance
   # alongside the indicator's computed values for that tick.
   class IndicatorsSource
+    include IndicatorsRegistry
+
     attr_reader :series, :source, :dominant_cycles, :pivots
 
     def initialize(series:, source:)
       @series = series
       @source = source
+
       @indicators = {}
       @ordered_indicators = []
+      define_indicator_accessors(indicator_source: self)
+
       @dominant_cycles = DominantCyclesSource.new(indicator_source: self)
       @pivots = PivotsSource.new(indicator_source: self)
     end
@@ -35,20 +40,19 @@ module Quant
       @ordered_indicators.each { |indicator| indicator << tick }
     end
 
-    def adx; indicator(Indicators::Adx) end
-    def atr; indicator(Indicators::Atr) end
-    def cci; indicator(Indicators::Cci) end
-    def decycler; indicator(Indicators::Decycler) end
-    def frama; indicator(Indicators::Frama) end
-    def mama; indicator(Indicators::Mama) end
-    def mesa; indicator(Indicators::Mesa) end
-    def ping; indicator(Indicators::Ping) end
-
     # Attaches a given Indicator class and defines the method for
     # accessing it using the given name.  Indicators take care of
     # computing their values when first attached to a populated
     # series.
     #
+    # NOTE: You can also use the `register` method on the indicator class to
+    # accomplish the same thing.  `attach` lets you inject a custom indicator
+    # at run-time when you have an instance of {Quant::IndicatorsSource} while
+    # the `register` method is used to define the indicator at load-time.
+    #
+    # NOTE Calling `attach` also registers the indicator with the framework, so
+    # you only have to `attach` once.
+    #
     # The indicators shipped with the library are all wired into the framework, thus
     # this method should be used for custom indicators not shipped with the library.
     #
@@ -57,6 +61,7 @@ module Quant
     # @example
     #   series.indicators.oc2.attach(name: :foo, indicator_class: Indicators::Foo)
     def attach(name:, indicator_class:)
+      self.class.register(name:, indicator_class:)
       define_singleton_method(name) { indicator(indicator_class) }
     end
 

data/lib/quant/pivots_source.rb

@@ -4,21 +4,9 @@ module Quant
   class PivotsSource
     def initialize(indicator_source:)
       @indicator_source = indicator_source
+      indicator_source.define_indicator_accessors(indicator_source: self)
     end
 
-    def atr; indicator(Indicators::Pivots::Atr) end
-    def bollinger; indicator(Indicators::Pivots::Bollinger) end
-    def camarilla; indicator(Indicators::Pivots::Camarilla) end
-    def classic; indicator(Indicators::Pivots::Classic) end
-    def demark; indicator(Indicators::Pivots::Demark) end
-    def donchian; indicator(Indicators::Pivots::Donchian) end
-    def fibbonacci; indicator(Indicators::Pivots::Fibbonacci) end
-    def guppy; indicator(Indicators::Pivots::Guppy) end
-    def keltner; indicator(Indicators::Pivots::Keltner) end
-    def murrey; indicator(Indicators::Pivots::Murrey) end
-    def traditional; indicator(Indicators::Pivots::Traditional) end
-    def woodie; indicator(Indicators::Pivots::Woodie) end
-
     private
 
     def indicator(indicator_class)

data/lib/quant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quant
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/quantitative.rb

@@ -29,6 +29,12 @@ loader.inflector.inflect "version" => "VERSION"
 loader.setup
 
 # Refinements aren't autoloaded by Zeitwerk, so we need to require them manually.
-%w(refinements).each do |sub_folder|
-  Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
-end
+# %w(refinements).each do |sub_folder|
+#   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
+# end
+
+refinements_folder = File.join(quant_folder, "refinements")
+indicators_folder = File.join(quant_folder, "indicators")
+
+loader.eager_load_dir(refinements_folder)
+loader.eager_load_dir(indicators_folder)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-01 00:00:00.000000000 Z
+date: 2024-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -77,13 +77,13 @@ files:
 - lib/quant/indicators/dominant_cycles/half_period.rb
 - lib/quant/indicators/dominant_cycles/homodyne.rb
 - lib/quant/indicators/dominant_cycles/phase_accumulator.rb
+- lib/quant/indicators/ema.rb
 - lib/quant/indicators/frama.rb
 - lib/quant/indicators/indicator.rb
 - lib/quant/indicators/indicator_point.rb
 - lib/quant/indicators/mama.rb
 - lib/quant/indicators/mesa.rb
 - lib/quant/indicators/ping.rb
-- lib/quant/indicators/pivot.rb
 - lib/quant/indicators/pivots/atr.rb
 - lib/quant/indicators/pivots/bollinger.rb
 - lib/quant/indicators/pivots/camarilla.rb
@@ -94,8 +94,14 @@ files:
 - lib/quant/indicators/pivots/guppy.rb
 - lib/quant/indicators/pivots/keltner.rb
 - lib/quant/indicators/pivots/murrey.rb
+- lib/quant/indicators/pivots/pivot.rb
 - lib/quant/indicators/pivots/traditional.rb
 - lib/quant/indicators/pivots/woodie.rb
+- lib/quant/indicators/rocket_rsi.rb
+- lib/quant/indicators/roofing.rb
+- lib/quant/indicators/rsi.rb
+- lib/quant/indicators/snr.rb
+- lib/quant/indicators_registry.rb
 - lib/quant/indicators_source.rb
 - lib/quant/indicators_sources.rb
 - lib/quant/interval.rb

data/lib/quant/indicators/pivot.rb

@@ -1,107 +0,0 @@
-module Quant
-  module Indicators
-    class PivotPoint < IndicatorPoint
-      attribute :high_price
-      attribute :avg_high, default: :high_price
-      attribute :highest, default: :input
-
-      attribute :low_price
-      attribute :avg_low, default: :low_price
-      attribute :lowest, default: :input
-
-      attribute :range, default: 0.0
-      attribute :avg_range, default: 0.0
-      attribute :std_dev, default: 0.0
-
-      def bands
-        @bands ||= { 0 => input }
-      end
-
-      def [](band)
-        bands[band]
-      end
-
-      def []=(band, value)
-        bands[band] = value
-      end
-
-      def key?(band)
-        bands.key?(band)
-      end
-
-      def midpoint
-        bands[0]
-      end
-      alias :h0 :midpoint
-      alias :l0 :midpoint
-
-      def midpoint=(value)
-        bands[0] = value
-      end
-      alias :h0= :midpoint=
-      alias :l0= :midpoint=
-
-      (1..8).each do |band|
-        define_method("h#{band}") { bands[band] }
-        define_method("h#{band}=") { |value| bands[band] = value }
-
-        define_method("l#{band}") { bands[-band] }
-        define_method("l#{band}=") { |value| bands[-band] = value }
-      end
-    end
-
-    class Pivot < Indicator
-      def points_class
-        Quant::Indicators::PivotPoint
-      end
-
-      def band?(band)
-        p0.key?(band)
-      end
-
-      def period
-        dc_period
-      end
-
-      def averaging_period
-        min_period
-      end
-
-      def period_midpoints
-        period_points(period).map(&:midpoint)
-      end
-
-      def compute
-        compute_extents
-        compute_value
-        compute_midpoint
-        compute_bands
-      end
-
-      def compute_midpoint
-        p0.midpoint = p0.input
-      end
-
-      def compute_value
-        # No-op -- override in subclasses
-      end
-
-      def compute_bands
-        # No-op -- override in subclasses
-      end
-
-      def compute_extents
-        period_midpoints.tap do |midpoints|
-          p0.high_price = t0.high_price
-          p0.low_price = t0.low_price
-          p0.highest = midpoints.max
-          p0.lowest = midpoints.min
-          p0.range = p0.high_price - p0.low_price
-          p0.avg_low = super_smoother(:low_price, previous: :avg_low, period: averaging_period)
-          p0.avg_high = super_smoother(:high_price, previous: :avg_high, period: averaging_period)
-          p0.avg_range = super_smoother(:range, previous: :avg_range, period: averaging_period)
-        end
-      end
-    end
-  end
-end