quantitative 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3db79bcbb841511c94568e330f60dfb6b68178ae874c56b867c17c538510a01
-  data.tar.gz: c5da8745035d84023886dcc8fba53f0df473c404b979e084385f6d9a7e19d536
+  metadata.gz: 6b5786b75635cde82e7919fce6b8fcd568724b27fc2810efe6db36a7e6dd09cc
+  data.tar.gz: 3a6fb86c25bb4f2b1e4994710539bfb528377ef57531e6845a4417c87fc86e29
 SHA512:
-  metadata.gz: 23c01e976533a62eddd80d5a774c55d23c644f6b9902392277f8a3450849f46a8dd8ead5588d8cc798cbaa36cce6c7ca7404ed332d4b41d6707982fb8e85c7bc
-  data.tar.gz: 769c9951b5af3cef2f9a4b93c4a49bd13f33876daa18ba90cf78a00503bfea1e87d8fa4ece964e72f0e15dbc712ef857bf3fa102d438e982d308e00a4c376b9d
+  metadata.gz: 5ae30c5b971d6c7bd41e3c2b764e7d95438931790271133dc0e3a476a371affddfdcf06355ffa933240c0c9952fd8fa5e4212c496c95c80f028de7399d3b129f
+  data.tar.gz: 9ff8aeaf24800a7208e51f836dd7c7c3621b2e2e3a7f1e8820d89f6fc5cd56dd3c4b762c478d221c6ef7279f62c0df75ae1a19f6a4d34e7ba82e116e6a10a790

data/Gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in quantitative.gemspec
+# Specify your gem"s dependencies in quantitative.gemspec
 gemspec
 
 gem "rake", "~> 13.0"
@@ -18,7 +18,12 @@ gem "guard-rspec", "~> 4.7"
 gem "yard", "~> 0.9"
 gem "benchmark-ips", "~> 2.9"
 
-gem 'rspec-github'
-gem 'simplecov'
-gem 'simplecov-cobertura'
+gem "rspec-github"
 
+# Test coverage and profiling
+gem "simplecov"
+gem "simplecov-cobertura"
+gem "stackprof", require: false
+gem "test-prof", require: false
+gem "vernier", require: false
+gem "ruby-prof", require: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.2.0)
+    quantitative (0.2.2)
       oj (~> 3.10)
 
 GEM
@@ -107,6 +107,7 @@ GEM
       rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
+    ruby-prof (1.7.0)
     ruby-progressbar (1.13.0)
     shellany (0.0.1)
     simplecov (0.22.0)
@@ -118,9 +119,12 @@ GEM
       simplecov (~> 0.19)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    stackprof (0.2.26)
     stringio (3.1.0)
+    test-prof (1.3.2)
     thor (1.3.0)
     unicode-display_width (2.5.0)
+    vernier (0.5.1)
     yard (0.9.34)
 
 PLATFORMS
@@ -138,8 +142,12 @@ DEPENDENCIES
   rspec-github
   rubocop (~> 1.21)
   rubocop-rspec
+  ruby-prof
   simplecov
   simplecov-cobertura
+  stackprof
+  test-prof
+  vernier
   yard (~> 0.9)
 
 BUNDLED WITH

data/lib/quant/dominant_cycle_indicators.rb

@@ -0,0 +1,52 @@
+
+require_relative 'indicators_proxy'
+
+module Quant
+  # Dominant Cycles measure the primary cycle within a given range.  By default, the library
+  # is wired to look for cycles between 10 and 48 bars.  These values can be adjusted by setting
+  # the `min_period` and `max_period` configuration values in {Quant::Config}.
+  #
+  #    Quant.configure_indicators(min_period: 8, max_period: 32)
+  #
+  # The default dominant cycle kind is the `half_period` filter.  This can be adjusted by setting
+  # the `dominant_cycle_kind` configuration value in {Quant::Config}.
+  #
+  #    Quant.configure_indicators(dominant_cycle_kind: :band_pass)
+  #
+  # The purpose of these indicators is to compute the dominant cycle and underpin the various
+  # indicators that would otherwise be setting an arbitrary lookback period.  This makes the
+  # indicators adaptive and auto-tuning to the market dynamics.  Or so the theory goes!
+  class DominantCycleIndicators < IndicatorsProxy
+    # 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
+
+    # 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 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
+
+    # 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
+
+    # Static, arbitrarily set period.
+    def half_period; indicator(Indicators::DominantCycles::HalfPeriod) end
+  end
+end

data/lib/quant/errors.rb

@@ -10,6 +10,10 @@ module Quant
     # {Quant::Interval} with an invalid value.
     class InvalidInterval < Error; end
 
+    # {InvalidIndicatorSource} is raised when attempting to reference
+    # an indicator through a source that has not been prepared, yet.
+    class InvalidIndicatorSource < Error; end
+
     # {InvalidResolution} is raised when attempting to instantiate
     # an {Quant::Resolution} with a resolution value that has not been defined.
     class InvalidResolution < Error; end

data/lib/quant/indicators/adx.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "indicator_point"
+require_relative "indicator"
+
+module Quant
+  class Indicators
+    class AdxPoint < IndicatorPoint
+      attribute :dmu, default: 0.0
+      attribute :dmd, default: 0.0
+      attribute :dmu_ema, default: 0.0
+      attribute :dmd_ema, default: 0.0
+      attribute :diu, default: 0.0
+      attribute :did, default: 0.0
+      attribute :di, default: 0.0
+      attribute :di_ema, default: 0.0
+      attribute :value, default: 0.0
+      attribute :inst_stoch, default: 0.0
+      attribute :stoch, default: 0.0
+      attribute :stoch_up, default: false
+      attribute :stoch_turned, default: false
+      attribute :ssf, default: 0.0
+      attribute :hp, default: 0.0
+    end
+
+    class Adx < Indicator
+      def alpha
+        bars_to_alpha(dc_period)
+      end
+
+      def scale
+        1.0
+      end
+
+      def period
+        dc_period
+      end
+
+      def atr_point
+        series.indicators[source].atr.points[t0]
+      end
+
+      def compute
+        # To calculate the ADX, first determine the + and - directional movement, or DM.
+        # The +DM and -DM are found by calculating the "up-move," or current high minus
+        # the previous high, and "down-move," or current low minus the previous low.
+        # If the up-move is greater than the down-move and greater than zero, the +DM equals the up-move;
+        # otherwise, it equals zero. If the down-move is greater than the up-move and greater than zero,
+        # the -DM equals the down-move; otherwise, it equals zero.
+        dm_highs = [t0.high_price - t1.high_price, 0.0].max
+        dm_lows  = [t0.low_price - t1.low_price, 0.0].max
+
+        p0.dmu = dm_highs > dm_lows ? 0.0 : dm_highs
+        p0.dmd = dm_lows > dm_highs ? 0.0 : dm_lows
+
+        p0.dmu_ema = three_pole_super_smooth :dmu, period:, previous: :dmu_ema
+        p0.dmd_ema = three_pole_super_smooth :dmd, period:, previous: :dmd_ema
+
+        atr_value = atr_point.fast * scale
+        return if atr_value == 0.0 || @points.size < period
+
+        # The positive directional indicator, or +DI, equals 100 times the EMA of +DM divided by the ATR
+        # over a given number of time periods. Welles usually used 14 periods.
+        # The negative directional indicator, or -DI, equals 100 times the EMA of -DM divided by the ATR.
+        p0.diu = (100.0 * p0.dmu_ema) / atr_value
+        p0.did = (100.0 * p0.dmd_ema) / atr_value
+
+        # The ADX indicator itself equals 100 times the EMA of the absolute value of (+DI minus -DI)
+        # divided by (+DI plus -DI).
+        delta = p0.diu + p0.did
+        p0.di = (p0.diu - p1.did).abs / delta
+        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.stoch = three_pole_super_smooth :inst_stoch, period:, previous: :stoch
+      end
+    end
+  end
+end

data/lib/quant/indicators/atr.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "indicator_point"
+require_relative "indicator"
+
+module Quant
+  class Indicators
+    class AtrPoint < IndicatorPoint
+      attribute :tr, default: 0.0
+      attribute :period, default: :min_period
+      attribute :value, default: 0.0
+      attribute :slow, default: 0.0
+      attribute :fast, default: 0.0
+      attribute :inst_stoch, default: 0.0
+      attribute :stoch, default: 0.0
+      attribute :stoch_up, default: false
+      attribute :stoch_turned, default: false
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    class Atr < Indicator
+      attr_reader :points
+
+      def period
+        dc_period / 2
+      end
+
+      def fast_alpha
+        period_to_alpha(period)
+      end
+
+      def slow_alpha
+        period_to_alpha(2 * period)
+      end
+
+      # Typically, the Average True Range (ATR) is based on 14 periods and can be calculated on an intraday, daily, weekly
+      # or monthly basis. For this example, the ATR will be based on daily data. Because there must be a beginning, the first
+      # TR value is simply the High minus the Low, and the first 14-day ATR is the average of the daily TR values for the
+      # last 14 days. After that, Wilder sought to smooth the data by incorporating the previous period's ATR value.
+
+      # Current ATR = [(Prior ATR x 13) + Current TR] / 14
+
+      #   - Multiply the previous 14-day ATR by 13.
+      #   - Add the most recent day's TR value.
+      #   - Divide the total by 14
+
+      def compute
+        p0.period = period
+        p0.tr = (t1.high_price - t0.close_price).abs
+
+        p0.value = three_pole_super_smooth :tr, period:, previous: :value
+
+        p0.slow = (slow_alpha * p0.value) + ((1.0 - slow_alpha) * p1.slow)
+        p0.fast = (fast_alpha * p0.value) + ((1.0 - fast_alpha) * p1.fast)
+
+        p0.inst_stoch = stochastic :value, period:
+        p0.stoch = three_pole_super_smooth(:inst_stoch, previous: :stoch, period:).clamp(0, 100)
+        p0.stoch_up = p0.stoch >= 70
+        p0.stoch_turned = p0.stoch_up && !p1.stoch_up
+        compute_oscillator
+      end
+
+      def compute_oscillator
+        p0.osc = p0.value - wma(:value)
+        p0.crossed = :up if p0.osc >= 0 && p1.osc < 0
+        p0.crossed = :down if p0.osc <= 0 && p1.osc > 0
+      end
+    end
+  end
+end

data/lib/quant/indicators/cci.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class CciPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :real, default: 0.0
+      attribute :imag, default: 0.0
+      attribute :angle, default: 0.0
+      attribute :state, default: 0
+    end
+
+    # Correlation Cycle Index
+    # The very definition of a trend mode and a cycle mode makes it simple
+    # to create a state variable that identifies the market state. If the
+    # state is zero, the market is in a cycle mode. If the state is +1 the
+    # market is in a trend up. If the state is -1 the market is in a trend down.
+    #
+    # SOURCE: https://www.mesasoftware.com/papers/CORRELATION%20AS%20A%20CYCLE%20INDICATOR.pdf
+    class Cci < Indicator
+      def max_period
+        [min_period, dc_period].max
+      end
+
+      def compute_correlations
+        corr_real = Statistics::Correlation.new
+        corr_imag = Statistics::Correlation.new
+        arc = 2.0 * Math::PI / max_period.to_f
+        (0...max_period).each do |period|
+          radians = arc * period
+          prev_hp = p(period).hp
+          corr_real.add(prev_hp, Math.cos(radians))
+          corr_imag.add(prev_hp, -Math.sin(radians))
+        end
+        p0.real = corr_real.coefficient
+        p0.imag = corr_imag.coefficient
+      end
+
+      def compute_angle
+        # Compute the angle as an arctangent and resolve the quadrant
+        p0.angle = 90 + rad2deg(Math.atan(p0.real / p0.imag))
+        p0.angle -= 180 if p0.imag > 0
+
+        # Do not allow the rate change of angle to go negative
+        p0.angle = p1.angle if (p0.angle < p1.angle) && (p1.angle - p0.angle) < 270
+      end
+
+      def compute_state
+        return unless (p0.angle - p1.angle).abs < 9
+
+        p0.state = p0.angle < 0 ? -1 : 1
+      end
+
+      def compute
+        p0.hp = two_pole_butterworth :input, previous: :hp, period: min_period
+
+        compute_correlations
+        compute_angle
+        compute_state
+      end
+    end
+  end
+end

data/lib/quant/indicators/decycler.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    # The decycler oscillator can be useful for determining the transition be- tween uptrends and downtrends by the crossing of the zero
+    # line. Alternatively, the changes of slope of the decycler oscillator are easier to identify than the changes in slope of the
+    # original decycler. Optimum cutoff periods can easily be found by experimentation.
+    #
+    # 1. A decycler filter functions the same as a low-pass filter.
+    # 2. A decycler filter is created by subtracting the output of a high-pass filter from the input, thereby removing the
+    #    high-frequency components by cancellation.
+    # 3. A decycler filter has very low lag.
+    # 4. A decycler oscillator is created by subtracting the output of a high-pass filter having a shorter cutoff period from the
+    #    output of another high-pass filter having a longer cutoff period.
+    # 5. A decycler oscillator shows transitions between uptrends and down-trends at the zero crossings.
+    class DecyclerPoint < IndicatorPoint
+      attr_accessor :decycle, :hp1, :hp2, :osc, :peak, :agc, :ift
+
+      def to_h
+        {
+          "dc" => decycle,
+          "hp1" => hp1,
+          "hp2" => hp2,
+          "osc" => osc,
+        }
+      end
+
+      def initialize_data_points(indicator:)
+        @decycle = oc2
+        @hp1 = 0.0
+        @hp2 = 0.0
+        @osc = 0.0
+        @peak = 0.0
+        @agc = 0.0
+      end
+    end
+
+    class Decycler < Indicator
+      def max_period
+        dc_period
+      end
+
+      def min_period
+        settings.min_period
+      end
+
+      def compute_decycler
+        alpha = period_to_alpha(max_period)
+        p0.decycle = (alpha / 2) * (p0.oc2 + p1.oc2) + (1.0 - alpha) * p1.decycle
+      end
+
+      # alpha1 = (Cosine(.707*360 / HPPeriod1) + Sine (.707*360 / HPPeriod1) - 1) / Cosine(.707*360 / HPPeriod1);
+      # HP1 = (1 - alpha1 / 2)*(1 - alpha1 / 2)*(Close - 2*Close[1] + Close[2]) + 2*(1 - alpha1)*HP1[1] - (1 - alpha1)*(1 - alpha1)*HP1[2];
+      def compute_hp(period, hp)
+        radians = deg2rad(360)
+        c = Math.cos(0.707 * radians / period)
+        s = Math.sin(0.707 * radians / period)
+        alpha = (c + s - 1) / c
+        (1 - alpha / 2)**2 * (p0.oc2 - 2 * p1.oc2 + p2.oc2) + 2 * (1 - alpha) * p1.send(hp) - (1 - alpha) * (1 - alpha) * p2.send(hp)
+      end
+
+      def compute_oscillator
+        p0.hp1 = compute_hp(min_period, :hp1)
+        p0.hp2 = compute_hp(max_period, :hp2)
+        p0.osc = p0.hp2 - p0.hp1
+      end
+
+      def compute_agc
+        p0.peak = [p0.osc.abs, 0.991 * p1.peak].max
+        p0.agc = p0.peak.zero? ? p0.osc : p0.osc / p0.peak
+      end
+
+      def compute_ift
+        p0.ift = ift(p0.agc, 5.0)
+      end
+
+      def compute
+        compute_decycler
+        compute_oscillator
+        compute_agc
+        compute_ift
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator_point"
 require_relative "dominant_cycle"
 
@@ -22,20 +24,20 @@ module Quant
         attribute :reversal, default: false
       end
 
-      # Auto-Correlation Reversals
+      # Auto-Correlation Reversals is a method of computing the dominant cycle
+      # by correlating the data stream with itself delayed by a lag.
+      # Construction of the autocorrelation periodogram starts with the
+      # autocorrelation function using the minimum three bars of averaging.
+      # The cyclic information is extracted using a discrete Fourier transform
+      # (DFT) of the autocorrelation results.
       class Acr < DominantCycle
-        def average_length
-          3 # AvgLength
-        end
-
-        def bandwidth
-          deg2rad(370)
-        end
+        BANDWIDTH_DEGREES = 370
+        BANDWIDTH_RADIANS = BANDWIDTH_DEGREES * Math::PI / 180.0
 
         def compute_auto_correlations
           (min_period..max_period).each do |period|
             corr = Statistics::Correlation.new
-            average_length.times do |lookback_period|
+            micro_period.times do |lookback_period|
               corr.add(p(lookback_period).filter, p(period + lookback_period).filter)
             end
             p0.corr[period] = corr.coefficient
@@ -46,8 +48,8 @@ module Quant
           p0.maxpwr = 0.995 * p1.maxpwr
 
           (min_period..max_period).each do |period|
-            (average_length..max_period).each do |n|
-              radians = bandwidth * n / period
+            (micro_period..max_period).each do |n|
+              radians = BANDWIDTH_RADIANS * n / period
               p0.cospart[period] += p0.corr[n] * Math.cos(radians)
               p0.sinpart[period] += p0.corr[n] * Math.sin(radians)
             end
@@ -98,4 +100,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant
@@ -14,6 +16,11 @@ module Quant
         attribute :direction, default: :flat
       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 revoved, leaving only the cyclical
+      # component.  Then we count number of iterations between zero crossings
+      # and this is the `period` of the dominant cycle.
       class BandPass < DominantCycle
         def bandwidth
           0.75

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

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
     class DominantCycles
-      # 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 compo- nent. Further, the angular frequency is defined
-      # as the rate change of phase. We can use these facts to derive the cycle period.
+      # 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.
       class Differential < DominantCycle
         def compute_period
           p0.ddd = (p0.q2 * (p0.i2 - p1.i2)) - (p0.i2 * (p0.q2 - p1.q2))
@@ -16,4 +20,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,7 +1,23 @@
+# frozen_string_literal: true
+
 require_relative "../indicator"
 
 module Quant
   class Indicators
+    # Dominant Cycles measure the primary cycle within a given range.  By default, the library
+    # is wired to look for cycles between 10 and 48 bars.  These values can be adjusted by setting
+    # the `min_period` and `max_period` configuration values in {Quant::Config}.
+    #
+    #    Quant.configure_indicators(min_period: 8, max_period: 32)
+    #
+    # The default dominant cycle kind is the `half_period` filter.  This can be adjusted by setting
+    # the `dominant_cycle_kind` configuration value in {Quant::Config}.
+    #
+    #    Quant.configure_indicators(dominant_cycle_kind: :band_pass)
+    #
+    # The purpose of these indicators is to compute the dominant cycle and underpin the various
+    # indicators that would otherwise be setting an arbitrary lookback period.  This makes the
+    # indicators adaptive and auto-tuning to the market dynamics.  Or so the theory goes!
     class DominantCycles
       class DominantCyclePoint < Quant::Indicators::IndicatorPoint
         attribute :smooth, default: 0.0
@@ -39,6 +55,8 @@ module Quant
           p0.inst_period = p0.inst_period.clamp(min_period, max_period)
         end
 
+        attr_reader :points
+
         # constrain magnitude of change in phase
         def constrain_period_magnitude_change
           p0.inst_period = [1.5 * p1.inst_period, p0.inst_period].min
@@ -60,11 +78,6 @@ module Quant
           [p0.period.to_i, min_period].max
         end
 
-        def period_points(max_period)
-          extent = [values.size, max_period].min
-          values[-extent, extent]
-        end
-
         def compute
           compute_input_data_points
           compute_quadrature_components
@@ -125,4 +138,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "dominant_cycle"
+
+module Quant
+  class Indicators
+    class DominantCycles
+      # This dominant cycle indicator is based on the half period
+      # that is the midpoint of the `min_period` and `max_period`
+      # configured in the `Quant.config.indicators` object.
+      # Effectively providing a static, arbitrarily set period.
+      class HalfPeriodPoint < Quant::Indicators::IndicatorPoint
+        attribute :period, default: :half_period
+      end
+
+      class HalfPeriod < DominantCycle
+        def compute
+          # No-Op
+        end
+      end
+    end
+  end
+end

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

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require_relative "../indicator_point"
 require_relative "dominant_cycle"
 
 module Quant
   class Indicators
     class DominantCycles
-      # 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
+      # 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
       class Homodyne < DominantCycle
         def compute_period
           p0.re = (p0.i2 * p1.i2) + (p0.q2 * p1.q2)
@@ -14,7 +17,7 @@ module Quant
           p0.re = (0.2 * p0.re) + (0.8 * p1.re)
           p0.im = (0.2 * p0.im) + (0.8 * p1.im)
 
-          p0.inst_period = 360.0 / rad2deg(Math.atan(p0.im/p0.re)) if (p0.im != 0) && (p0.re != 0)
+          p0.inst_period = 360.0 / rad2deg(Math.atan(p0.im / p0.re)) if (p0.im != 0) && (p0.re != 0)
 
           constrain_period_magnitude_change
           constrain_period_bars
@@ -24,4 +27,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant
@@ -8,7 +10,7 @@ module Quant
       # at each sample by taking the arctangent of the ratio of the quadrature
       # component to the in-phase component. A delta phase is generated by
       # taking the difference of the phase between successive samples.
-      # At each sam- ple we can then look backwards, adding up the delta
+      # At each sample we can then look backwards, adding up the delta
       # phases.  When the sum of the delta phases reaches 360 degrees,
       # we must have passed through one full cycle, on average.  The process
       # is repeated for each new sample.
@@ -30,10 +32,12 @@ module Quant
 
           p0.accumulator_phase = Math.atan(p0.q1 / p0.i1) unless p0.i1.zero?
 
-          case
-          when p0.i1 < 0 && p0.q1 > 0 then p0.accumulator_phase = 180.0 - p0.accumulator_phase
-          when p0.i1 < 0 && p0.q1 < 0 then p0.accumulator_phase = 180.0 + p0.accumulator_phase
-          when p0.i1 > 0 && p0.q1 < 0 then p0.accumulator_phase = 360.0 - p0.accumulator_phase
+          if p0.i1 < 0 && p0.q1 > 0
+            p0.accumulator_phase = 180.0 - p0.accumulator_phase
+          elsif p0.i1 < 0 && p0.q1 < 0
+            p0.accumulator_phase = 180.0 + p0.accumulator_phase
+          elsif p0.i1 > 0 && p0.q1 < 0
+            p0.accumulator_phase = 360.0 - p0.accumulator_phase
           end
 
           p0.delta_phase = p1.accumulator_phase - p0.accumulator_phase

data/lib/quant/indicators/frama.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class FramaPoint < IndicatorPoint
+      attribute :frama, default: :input
+    end
+
+    # FRAMA (FRactal Adaptive Moving Average). A nonlinear moving average
+    # is derived using the Hurst exponent. It rapidly follows significant
+    # changes in price but becomes very flat in congestion zones so that
+    # bad whipsaw trades can be eliminated.
+    #
+    # SOURCE: http://www.mesasoftware.com/papers/FRAMA.pdf
+    class Frama < Indicator
+      using Quant
+
+      # The max_period is divided into two smaller, equal periods, so must be even
+      def max_period
+        @max_period ||= begin
+          mp = super
+          mp.even? ? mp : mp + 1
+        end
+      end
+
+      # def max_period
+      #   mp = dc_period
+      #   mp.even? ? mp : mp + 1
+      # end
+
+      def half_period
+        max_period / 2
+      end
+
+      def compute
+        pp = period_points(max_period).map(&:input)
+        return if pp.size < max_period
+
+        n3 = (pp.maximum - pp.minimum) / max_period
+
+        ppn2 = pp.first(half_period)
+        n2 = (ppn2.maximum - ppn2.minimum) / half_period
+
+        ppn1 = pp.last(half_period)
+        n1 = (ppn1.maximum - ppn1.minimum) / half_period
+
+        dimension = (Math.log(n1 + n2) - Math.log(n3)) / Math.log(2)
+        alpha = Math.exp(-4.6 * (dimension - 1.0)).clamp(0.01, 1.0)
+        p0.frama = (alpha * p0.input) + ((1 - alpha) * p1.frama)
+      end
+    end
+  end
+end

data/lib/quant/indicators/indicator.rb

@@ -19,6 +19,7 @@ module Quant
         @series = series
         @source = source
         @points = {}
+        series.new_indicator(self)
         series.each { |tick| self << tick }
       end
 
@@ -46,6 +47,14 @@ module Quant
         Quant.config.indicators.pivot_kind
       end
 
+      def dominant_cycle
+        series.indicators[source].dominant_cycle
+      end
+
+      def dc_period
+        dominant_cycle.points[t0].period
+      end
+
       def ticks
         @points.keys
       end
@@ -62,6 +71,11 @@ module Quant
         @points.size
       end
 
+      def period_points(max_period)
+        extent = [values.size, max_period].min
+        values[-extent, extent]
+      end
+
       attr_reader :p0, :p1, :p2, :p3
       attr_reader :t0, :t1, :t2, :t3
 

data/lib/quant/indicators/mama.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class MamaPoint < IndicatorPoint
+      attribute :smooth, default: 0.0
+      attribute :detrend, default: 0.0
+      attribute :re, default: 0.0
+      attribute :im, default: 0.0
+      attribute :i1, default: 0.0
+      attribute :q1, default: 0.0
+      attribute :ji, default: 0.0
+      attribute :jq, default: 0.0
+      attribute :i2, default: 0.0
+      attribute :q2, default: 0.0
+      attribute :period, default: :min_period
+      attribute :smooth_period, default: :min_period
+      attribute :mama, default: :input
+      attribute :fama, default: :input
+      attribute :gama, default: :input
+      attribute :dama, default: :input
+      attribute :lama, default: :input
+      attribute :faga, default: :input
+      attribute :phase, default: 0.0
+      attribute :delta_phase, default: 0.0
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    # https://www.mesasoftware.com/papers/MAMA.pdf
+    # MESA Adaptive Moving Average (MAMA) adapts to price movement in an
+    # entirely new and unique way. The adapation is based on the rate change
+    # of phase as measured by the Hilbert Transform Discriminator.
+    #
+    # This version of Ehler's MAMA indicator duplicates the computations
+    # present in the homodyne version of the dominant cycle indicator.
+    # Use this version of the indicator when you're using a different
+    # dominant cycle indicator other than the homodyne for the rest
+    # of your indicators.
+    class Mama < Indicator
+      # constrain between 6 and 50 bars
+      def constrain_period_bars
+        p0.period = p0.period.clamp(min_period, max_period)
+      end
+
+      # constrain magnitude of change in phase
+      def constrain_period_magnitude_change
+        p0.period = [1.5 * p1.period, p0.period].min
+        p0.period = [0.67 * p1.period, p0.period].max
+      end
+
+      # amplitude correction using previous period value
+      def compute_smooth_period
+        p0.period = ((0.2 * p0.period) + (0.8 * p1.period)).round
+        p0.smooth_period = ((0.33333 * p0.period) + (0.666667 * p1.smooth_period)).round
+      end
+
+      def homodyne_discriminator
+        p0.re = (p0.i2 * p1.i2) + (p0.q2 * p1.q2)
+        p0.im = (p0.i2 * p1.q2) - (p0.q2 * p1.i2)
+
+        p0.re = (0.2 * p0.re) + (0.8 * p1.re)
+        p0.im = (0.2 * p0.im) + (0.8 * p1.im)
+
+        p0.period = 360.0 / rad2deg(Math.atan(p0.im / p0.re)) if (p0.im != 0) && (p0.re != 0)
+
+        constrain_period_magnitude_change
+        constrain_period_bars
+        compute_smooth_period
+      end
+
+      def compute_dominant_cycle
+        p0.smooth = wma :input
+        p0.detrend = hilbert_transform :smooth, period: p1.period
+
+        # { Compute Inphase and Quadrature components }
+        p0.q1 = hilbert_transform :detrend, period: p1.period
+        p0.i1 = p3.detrend
+
+        # { Advance the phase of I1 and Q1 by 90 degrees }
+        p0.ji = hilbert_transform :i1, period: p1.period
+        p0.jq = hilbert_transform :q1, period: p1.period
+
+        # { Smooth the I and Q components before applying the discriminator }
+        p0.i2 = (0.2 * (p0.i1 - p0.jq)) + 0.8 * (p1.i2 || (p0.i1 - p0.jq))
+        p0.q2 = (0.2 * (p0.q1 + p0.ji)) + 0.8 * (p1.q2 || (p0.q1 + p0.ji))
+
+        homodyne_discriminator
+      end
+
+      def fast_limit
+        @fast_limit ||= bars_to_alpha(min_period / 2)
+      end
+
+      def slow_limit
+        @slow_limit ||= bars_to_alpha(max_period)
+      end
+
+      def compute_dominant_cycle_phase
+        p0.delta_phase = p1.phase - p0.phase
+        p0.delta_phase = 1.0 if p0.delta_phase < 1.0
+      end
+
+      FAMA = 0.500
+      GAMA = 0.950
+      DAMA = 0.125
+      LAMA = 0.100
+      FAGA = 0.050
+
+      def compute_moving_averages
+        alpha = [fast_limit / p0.delta_phase, slow_limit].max
+        p0.mama = (alpha * p0.input) + ((1.0 - alpha) * p1.mama)
+
+        p0.fama = (FAMA * alpha * p0.mama) + ((1.0 - (FAMA * alpha)) * p1.fama)
+        p0.gama = (GAMA * alpha * p0.mama) + ((1.0 - (GAMA * alpha)) * p1.gama)
+        p0.dama = (DAMA * alpha * p0.mama) + ((1.0 - (DAMA * alpha)) * p1.dama)
+        p0.lama = (LAMA * alpha * p0.mama) + ((1.0 - (LAMA * alpha)) * p1.lama)
+        p0.faga = (FAGA * alpha * p0.fama) + ((1.0 - (FAGA * alpha)) * p1.faga)
+      end
+
+      def compute_oscillator
+        p0.osc = p0.mama - p0.fama
+        p0.crossed = :up if p0.osc >= 0 && p1.osc < 0
+        p0.crossed = :down if p0.osc <= 0 && p1.osc > 0
+      end
+
+      def compute
+        compute_dominant_cycle
+        compute_dominant_cycle_phase
+        compute_moving_averages
+        compute_oscillator
+      end
+    end
+  end
+end

data/lib/quant/indicators/mesa.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    # The MESA inidicator
+    class MesaPoint < IndicatorPoint
+      attribute :mama, default: :input
+      attribute :fama, default: :input
+      attribute :dama, default: :input
+      attribute :gama, default: :input
+      attribute :lama, default: :input
+      attribute :faga, default: :input
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    # https://www.mesasoftware.com/papers/MAMA.pdf
+    # MESA Adaptive Moving Average (MAMA) adapts to price movement in an
+    # entirely new and unique way. The adapation is based on the rate change
+    # of phase as measured by the Hilbert Transform Discriminator.
+    #
+    # This version of Ehler's MAMA indicator ties into the homodyne
+    # dominant cycle indicator to provide a more efficient computation
+    # for this indicator.  If you're using the homodyne in all your
+    # indicators for the dominant cycle, then this version is useful
+    # as it avoids extra computational steps.
+    class Mesa < Indicator
+      def period
+        dc_period
+      end
+
+      def fast_limit
+        @fast_limit ||= bars_to_alpha(min_period / 2)
+      end
+
+      def slow_limit
+        @slow_limit ||= bars_to_alpha(max_period)
+      end
+
+      def homodyne_dominant_cycle
+        series.indicators[source].dominant_cycles.homodyne
+      end
+
+      def current_dominant_cycle
+        homodyne_dominant_cycle.points[t0]
+      end
+
+      def delta_phase
+        current_dominant_cycle.delta_phase
+      end
+
+      FAMA = 0.500
+      GAMA = 0.950
+      DAMA = 0.125
+      LAMA = 0.100
+      FAGA = 0.050
+
+      def compute
+        alpha = [fast_limit / delta_phase, slow_limit].max
+
+        p0.mama = (alpha * p0.input) + ((1.0 - alpha) * p1.mama)
+        p0.fama = (FAMA * alpha * p0.mama) + ((1.0 - (FAMA * alpha)) * p1.fama)
+        p0.gama = (GAMA * alpha * p0.mama) + ((1.0 - (GAMA * alpha)) * p1.gama)
+        p0.dama = (DAMA * alpha * p0.mama) + ((1.0 - (DAMA * alpha)) * p1.dama)
+        p0.lama = (LAMA * alpha * p0.mama) + ((1.0 - (LAMA * alpha)) * p1.lama)
+        p0.faga = (FAGA * alpha * p0.fama) + ((1.0 - (FAGA * alpha)) * p1.faga)
+
+        compute_oscillator
+      end
+
+      def compute_oscillator
+        p0.osc = p0.mama - p0.fama
+        p0.crossed = :up if p0.osc >= 0 && p1.osc < 0
+        p0.crossed = :down if p0.osc <= 0 && p1.osc > 0
+      end
+    end
+  end
+end

data/lib/quant/indicators.rb

@@ -6,9 +6,13 @@ module Quant
   #       used outside those shipped with the library.
   class Indicators < IndicatorsProxy
     def ping; indicator(Indicators::Ping) end
+    def adx; indicator(Indicators::Adx) end
+    def atr; indicator(Indicators::Atr) end
+    def mesa; indicator(Indicators::Mesa) end
+    def mama; indicator(Indicators::MAMA) end
 
     def dominant_cycles
-      @dominant_cycles ||= Indicators::DominantCycleIndicators.new(series:, source:)
+      @dominant_cycles ||= Quant::DominantCycleIndicators.new(series:, source:)
     end
   end
 end

data/lib/quant/indicators_proxy.rb

@@ -13,12 +13,21 @@ module Quant
   # By design, the {Quant::Indicator} class holds the {Quant::Ticks::Tick} instance
   # alongside the indicator's computed values for that tick.
   class IndicatorsProxy
-    attr_reader :series, :source, :indicators
+    attr_reader :series, :source, :dominant_cycle, :indicators
 
     def initialize(series:, source:)
       @series = series
       @source = source
       @indicators = {}
+      @dominant_cycle = dominant_cycle_indicator
+    end
+
+    def dominant_cycle_indicator
+      kind = Quant.config.indicators.dominant_cycle_kind.to_s
+      base_class_name = kind.split("_").map(&:capitalize).join
+      class_name = "Quant::Indicators::DominantCycles::#{base_class_name}"
+      indicator_class = Object.const_get(class_name)
+      indicator_class.new(series:, source:)
     end
 
     # Instantiates the indicator class and stores it in the indicators hash.  Once
@@ -36,6 +45,7 @@ module Quant
     # The IndicatorsProxy class is not responsible for enforcing
     # this order of events.
     def <<(tick)
+      dominant_cycle << tick
       indicators.each_value { |indicator| indicator << tick }
     end
 

data/lib/quant/indicators_sources.rb

@@ -7,6 +7,16 @@ module Quant
       @indicator_sources = {}
     end
 
+    def new_indicator(indicator)
+      @indicator_sources[indicator.source] ||= Indicators.new(series: @series, source: indicator.source)
+    end
+
+    def [](source)
+      return @indicator_sources[source] if @indicator_sources.key?(source)
+
+      raise Quant::Errors::InvalidIndicatorSource, "Invalid source, #{source.inspect}."
+    end
+
     def <<(tick)
       @indicator_sources.each_value { |indicator| indicator << tick }
     end

data/lib/quant/mixins/stochastic.rb

@@ -16,7 +16,7 @@ module Quant
       def stochastic(source, period:)
         subset = values.last(period).map{ |p| p.send(source) }
 
-        lowest, highest = subset.minimum, subset.maximum
+        lowest, highest = subset.minimum.to_f, subset.maximum.to_f
         return 0.0 if (highest - lowest).zero?
 
         100.0 * (subset[-1] - lowest) / (highest - lowest)

data/lib/quant/mixins/super_smoother.rb

@@ -2,8 +2,17 @@
 
 module Quant
   module Mixins
+    # Super Smoother Filters provide a way to smooth out the noise in a series
+    # without out introducing undesirable lag that you would other get with
+    # traditional moving averages.
+    #
+    # The EMA only reduces the amplitude at the Nyquist frequency by 13 dB.
+    # On the other hand, the SuperSmoother filter theoretically completely
+    # eliminates components at the Nyquist Frequency. The added benefit is
+    # that the SuperSmoother filter has significantly less lag than the EMA.
     module SuperSmoother
-      def two_pole_super_smooth(source, period:, previous: :ss)
+      # https://www.mesasoftware.com/papers/PredictiveIndicators.pdf
+      def two_pole_super_smooth(source, period:, previous:)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
         radians = Math.sqrt(2) * Math::PI / period
@@ -23,7 +32,7 @@ module Quant
       alias super_smoother two_pole_super_smooth
       alias ss2p two_pole_super_smooth
 
-      def three_pole_super_smooth(source, period:, previous: :ss)
+      def three_pole_super_smooth(source, period:, previous:)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
         radians = Math::PI / period

data/lib/quant/series.rb

@@ -101,6 +101,20 @@ module Quant
       "#<#{self.class.name} symbol=#{symbol} interval=#{interval} ticks=#{ticks.size}>"
     end
 
+    # When the first indicator is instantiated, it will also lead to instantiating
+    # the dominant cycle indicator.  The `new_indicator_lock` prevents reentrant calls
+    # to the `new_indicator` method with infinite recursion.
+    def new_indicator(indicator)
+      return if @new_indicator_lock
+
+      begin
+        @new_indicator_lock = true
+        indicators.new_indicator(indicator)
+      ensure
+        @new_indicator_lock = false
+      end
+    end
+
     def <<(tick)
       tick = Ticks::Spot.new(price: tick) if tick.is_a?(Numeric)
       indicators << tick unless tick.series?

data/lib/quant/settings/indicators.rb

@@ -8,14 +8,16 @@ module Quant
     # papers and books on the subject of technical analysis by John Ehlers where he variously suggests
     # a minimum period of 8 or 10 and a max period of 48.
     #
-    # The half period is the average of the max_period and min_period.
+    # The half period is the average of the max_period and min_period.  It is read-only and always computed
+    # relative to `min_period` and `max_period`.
+    #
     # The micro period comes from Ehler's writings on Swami charts and auto-correlation computations, which
     # is a period of 3 bars.  It is useful enough in various indicators to be its own setting.
     #
     # The dominant cycle kind is the kind of dominant cycle to use in the indicator.  The default is +:settings+
     # which means the dominant cycle is whatever the +max_period+ is set to.  It is not adaptive when configured
     # this way.  The other kinds are adaptive and are computed from the series data.  The choices are:
-    # * +:settings+  - the max_period is the dominant cycle and is not adaptive
+    # * +:half_period+  - the half_period is the dominant cycle and is not adaptive
     # * +:band_pass+ - The zero crossings of the band pass filter are used to compute the dominant cycle
     # * +:auto_correlation_reversal+ - The dominant cycle is computed from the auto-correlation of the series.
     # * +:homodyne+ - The dominant cycle is computed from the homodyne discriminator.
@@ -48,8 +50,8 @@ module Quant
         new
       end
 
-      attr_accessor :max_period, :min_period, :half_period, :micro_period
-      attr_accessor :dominant_cycle_kind, :pivot_kind
+      attr_reader :max_period, :min_period, :half_period
+      attr_accessor :micro_period, :dominant_cycle_kind, :pivot_kind
 
       def initialize(**settings)
         @max_period = settings[:max_period] || Settings::MAX_PERIOD
@@ -64,14 +66,22 @@ module Quant
       def apply_settings(**settings)
         @max_period = settings.fetch(:max_period, @max_period)
         @min_period = settings.fetch(:min_period, @min_period)
-        @half_period = settings.fetch(:half_period, @half_period || compute_half_period)
+        compute_half_period
         @micro_period = settings.fetch(:micro_period, @micro_period)
         @dominant_cycle_kind = settings.fetch(:dominant_cycle_kind, @dominant_cycle_kind)
         @pivot_kind = settings.fetch(:pivot_kind, @pivot_kind)
       end
 
+      def max_period=(value)
+        (@max_period = value).tap { compute_half_period }
+      end
+
+      def min_period=(value)
+        (@min_period = value).tap { compute_half_period }
+      end
+
       def compute_half_period
-        (max_period + min_period) / 2
+        @half_period = (max_period + min_period) / 2
       end
     end
   end

data/lib/quant/settings.rb

@@ -23,7 +23,7 @@ module Quant
     ).freeze
 
     DOMINANT_CYCLE_KINDS = %i(
-      settings
+      half_period
       band_pass
       auto_correlation_reversal
       homodyne

data/lib/quant/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-11 00:00:00.000000000 Z
+date: 2024-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -48,18 +48,26 @@ files:
 - lib/quant/asset_class.rb
 - lib/quant/attributes.rb
 - lib/quant/config.rb
+- lib/quant/dominant_cycle_indicators.rb
 - lib/quant/errors.rb
 - lib/quant/experimental.rb
 - lib/quant/indicators.rb
-- lib/quant/indicators/dominant_cycle_indicators.rb
+- lib/quant/indicators/adx.rb
+- lib/quant/indicators/atr.rb
+- lib/quant/indicators/cci.rb
+- lib/quant/indicators/decycler.rb
 - lib/quant/indicators/dominant_cycles/acr.rb
 - lib/quant/indicators/dominant_cycles/band_pass.rb
 - lib/quant/indicators/dominant_cycles/differential.rb
 - lib/quant/indicators/dominant_cycles/dominant_cycle.rb
+- 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/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_proxy.rb
 - lib/quant/indicators_sources.rb

data/lib/quant/indicators/dominant_cycle_indicators.rb

@@ -1,10 +0,0 @@
-module Quant
-  class DominantCycleIndicators < IndicatorsProxy
-    def acr; indicator(Indicators::DominantCycles::Acr) end
-    def band_pass; indicator(Indicators::DominantCycles::BandPass) end
-    def homodyne; indicator(Indicators::DominantCycles::Homodyne) end
-
-    def differential; indicator(Indicators::DominantCycles::Differential) end
-    def phase_accumulator; indicator(Indicators::DominantCycles::PhaseAccumulator) end
-  end
-end