quantitative 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf0aa73684247efc7bc9750c27c856a094fa362d99c1eba73bd70457da8f3a97
-  data.tar.gz: 56dcaa82230328cb44149ceb957420484217e33c6f601ea135997391bfb95440
+  metadata.gz: 6b5786b75635cde82e7919fce6b8fcd568724b27fc2810efe6db36a7e6dd09cc
+  data.tar.gz: 3a6fb86c25bb4f2b1e4994710539bfb528377ef57531e6845a4417c87fc86e29
 SHA512:
-  metadata.gz: b674a5e4408a69039cf2c7ad2378d065e3f88b409a7530108af1bfc5a186a02690cba8ffb1c8d40a87ad69368f302d9eec0211135beec7db6a9c51c4e1be46d3
-  data.tar.gz: e7d7693cd878ebe777f81ca0d90b4f305e645c8547aa9f420cccb4a4f9b53920211a2b7f49af146508756e6e38f5cc7e0c4b57f1c8abdd722f65bd3409abd02f
+  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.1)
+    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/{indicators/dominant_cycle_indicators.rb → dominant_cycle_indicators.rb}

@@ -1,3 +1,6 @@
+
+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

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"
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
     class DominantCycles
@@ -18,4 +20,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator"
 
 module Quant
@@ -76,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
@@ -141,4 +138,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator_point"
 require_relative "dominant_cycle"
 
@@ -15,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
@@ -25,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
@@ -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

@@ -71,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/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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-16 00:00:00.000000000 Z
+date: 2024-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -48,10 +48,14 @@ 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
@@ -59,8 +63,11 @@ 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/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