quantitative 0.1.10 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50dde4546ee2c241a00695bf5928fb76c92a7323e8b1a2d5d0090db74bbebee5
-  data.tar.gz: f6432d642ac5111cd4fe0cb6b041ada60af39ba41033195c949b0126184ae180
+  metadata.gz: bf0aa73684247efc7bc9750c27c856a094fa362d99c1eba73bd70457da8f3a97
+  data.tar.gz: 56dcaa82230328cb44149ceb957420484217e33c6f601ea135997391bfb95440
 SHA512:
-  metadata.gz: d48777cee5009e48b5d3ef6c531029fdaa8c9629b37223ad919aacd53c29caf13258d7cddc28413788b61ec086af0abde606996cdac3c7012565ec2cea5b6e77
-  data.tar.gz: 8c9fa61a0f4b4c21b890c6895d4e74ba870fb92336cd30bb822e13bad5e49e9ee8d4b45e639171a73ab8c04e1756088e79979231a557a41ad9effa8ee1660e6b
+  metadata.gz: b674a5e4408a69039cf2c7ad2378d065e3f88b409a7530108af1bfc5a186a02690cba8ffb1c8d40a87ad69368f302d9eec0211135beec7db6a9c51c4e1be46d3
+  data.tar.gz: e7d7693cd878ebe777f81ca0d90b4f305e645c8547aa9f420cccb4a4f9b53920211a2b7f49af146508756e6e38f5cc7e0c4b57f1c8abdd722f65bd3409abd02f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.1.10)
+    quantitative (0.2.1)
       oj (~> 3.10)
 
 GEM

data/lib/quant/attributes.rb

@@ -98,85 +98,73 @@ module Quant
 
     module InstanceMethods
       # Makes some assumptions about the class's initialization having a +tick+ keyword argument.
-      #
-      # The challenge here is that we prepend this module to the class, and we are
-      # initializing attributes before the owning class gets the opportunity to initialize
-      # variables that we wanted to depend on with being able to define a default
-      # value that could set default values from a +tick+ method.
-      #
-      # Ok for now.  May need to be more flexible in the future.  Alternative strategy could be
-      # to lazy eval the default value the first time it is accessed.
-      def initialize(*args, **kwargs)
-        initialize_attributes(tick: kwargs[:tick])
-        super(*args, **kwargs)
+      # If one does exist, the +tick+ is considered as a potential source for the declared defaults
+      def initialize(...)
+        super(...)
+        initialize_attributes
+      end
+
+      # Returns an array of all classes in the hierarchy, starting with the current class
+      def self_and_ancestors
+        [this_class = self.class].tap do |classes|
+          classes << this_class = this_class.superclass while !this_class.nil?
+        end
       end
 
       # Iterates over all defined attributes in a child => parent hierarchy,
       # and yields the name and entry for each.
       def each_attribute(&block)
-        klass = self.class
-        loop do
-          attributes = Attributes.registry[klass]
-          break if attributes.nil?
-
-          attributes.each{ |name, entry| block.call(name, entry) }
-          klass = klass.superclass
+        self_and_ancestors.select{ |klass| Attributes.registry[klass] }.each do |klass|
+          Attributes.registry[klass].each{ |name, entry| block.call(name, entry) }
         end
       end
 
       # The default value can be one of the following:
-      # - A symbol that is a method on the instance responds to
+      # - A symbol that is a method the instance responds to
       # - A symbol that is a method that the instance's tick responds to
       # - A Proc that is bound to the instance
       # - An immediate value (Integer, Float, Boolean, etc.)
-      def default_value_for(entry, new_tick)
-        # let's not assume tick is always available/implemented
-        # can get from instance or from initializer passed here as `new_tick`
-        current_tick = new_tick
-        current_tick ||= tick if respond_to?(:tick)
-
-        if entry[:default].is_a?(Symbol) && respond_to?(entry[:default])
-          send(entry[:default])
+      def default_value_for(entry)
+        return instance_exec(&entry[:default]) if entry[:default].is_a?(Proc)
+        return entry[:default] unless entry[:default].is_a?(Symbol)
+        return send(entry[:default]) if respond_to?(entry[:default])
+        return tick.send(entry[:default]) if tick.respond_to?(entry[:default])
 
-        elsif entry[:default].is_a?(Symbol) && current_tick.respond_to?(entry[:default])
-          current_tick.send(entry[:default])
-
-        elsif entry[:default].is_a?(Proc)
-          instance_exec(&entry[:default])
-
-        else
-          entry[:default]
-        end
+        entry[:default]
       end
 
       # Initializes the defined attributes with default values and
       # defines accessor methods for each attribute.
       # If a child class redefines a parent's attribute, the child's
       # definition will be used.
-      def initialize_attributes(tick:)
+      def initialize_attributes
         each_attribute do |name, entry|
           # use the child's definition, skipping the parent's
           next if respond_to?(name)
 
           ivar_name = "@#{name}"
-          instance_variable_set(ivar_name, default_value_for(entry, tick))
-          define_singleton_method(name) { instance_variable_get(ivar_name) }
+          define_singleton_method(name) do
+            return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+
+            # Sets the default value when accessed and ivar is not already set
+            default_value_for(entry).tap { |value| instance_variable_set(ivar_name, value) }
+          end
           define_singleton_method("#{name}=") { |value| instance_variable_set(ivar_name, value) }
         end
       end
 
       # Serializes keys that have been defined as serializeable attributes
-      # Key values that are nil are removed from the hash
+      # Key values that are nil are omitted from the hash
       # @return [Hash] The serialized attributes as a Ruby Hash.
       def to_h
         {}.tap do |key_values|
           each_attribute do |name, entry|
             next unless entry[:key]
 
-            ivar_name = "@#{name}"
-            value = instance_variable_get(ivar_name)
+            value = send(name)
+            next unless value
 
-            key_values[entry[:key]] = value if value
+            key_values[entry[:key]] = value
           end
         end
       end

data/lib/quant/config.rb

@@ -14,6 +14,10 @@ module Quant
       end
     end
 
+    def self.default!
+      @config = Config.new
+    end
+
     def self.config
       @config ||= Config.new
     end
@@ -25,6 +29,10 @@ module Quant
     Config.config
   end
 
+  def default_configuration!
+    Config.default!
+  end
+
   def configure_indicators(**settings)
     config.apply_indicator_settings(**settings)
     yield config.indicators if block_given?

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/dominant_cycle_indicators.rb

@@ -0,0 +1,49 @@
+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/indicators/dominant_cycles/acr.rb

@@ -0,0 +1,101 @@
+require_relative "../indicator_point"
+require_relative "dominant_cycle"
+
+module Quant
+  class Indicators
+    class DominantCycles
+      class AcrPoint < DominantCyclePoint
+        attribute :hp, default: 0.0
+        attribute :filter, default: 0.0
+        attribute :interim_period, default: 0.0
+        attribute :inst_period, default: :min_period
+        attribute :period, default: 0.0
+        attribute :sp, default: 0.0
+        attribute :spx, default: 0.0
+        attribute :maxpwr, default: 0.0
+        attribute :r1, default: -> { Hash.new(0.0) }
+        attribute :corr, default: -> { Hash.new(0.0) }
+        attribute :pwr, default: -> { Hash.new(0.0) }
+        attribute :cospart, default: -> { Hash.new(0.0) }
+        attribute :sinpart, default: -> { Hash.new(0.0) }
+        attribute :sqsum, default: -> { Hash.new(0.0) }
+        attribute :reversal, default: false
+      end
+
+      # 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
+        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
+            micro_period.times do |lookback_period|
+              corr.add(p(lookback_period).filter, p(period + lookback_period).filter)
+            end
+            p0.corr[period] = corr.coefficient
+          end
+        end
+
+        def compute_powers
+          p0.maxpwr = 0.995 * p1.maxpwr
+
+          (min_period..max_period).each do |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
+            p0.sqsum[period] = p0.cospart[period]**2 + p0.sinpart[period]**2
+            p0.r1[period] = (0.2 * p0.sqsum[period]**2) + (0.8 * p1.r1[period])
+            p0.pwr[period] = p0.r1[period]
+            p0.maxpwr = [p0.maxpwr, p0.r1[period]].max
+          end
+          return if p0.maxpwr.zero?
+
+          (min_period..max_period).each do |period|
+            p0.pwr[period] = p0.r1[period] / p0.maxpwr
+          end
+        end
+
+        def compute_period
+          (min_period..max_period).each do |period|
+            if p0.pwr[period] >= 0.4
+              p0.spx += (period * p0.pwr[period])
+              p0.sp += p0.pwr[period]
+            end
+          end
+
+          p0.interim_period = p0.sp.zero? ? p1.period : p0.spx / p0.sp
+          p0.inst_period = two_pole_butterworth(:interim_period, previous: :period, period: min_period)
+          p0.period = p0.inst_period.round(0)
+        end
+
+        def compute_reversal
+          sum_deltas = 0
+          (min_period..max_period).each do |period|
+            sc1 = (p0.corr[period] + 1) * 0.5
+            sc2 = (p1.corr[period] + 1) * 0.5
+            sum_deltas += 1 if (sc1 > 0.5 && sc2 < 0.5) || (sc1 < 0.5 && sc2 > 0.5)
+          end
+          p0.reversal = sum_deltas > 24
+        end
+
+        def compute
+          p0.hp = two_pole_high_pass_filter(:input, period: max_period)
+          p0.filter = two_pole_butterworth(:hp, previous: :filter, period: min_period)
+
+          compute_auto_correlations
+          compute_powers
+          compute_period
+          compute_reversal
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require_relative "dominant_cycle"
+
+module Quant
+  class Indicators
+    class DominantCycles
+      class BandPassPoint < Quant::Indicators::IndicatorPoint
+        attribute :hp, default: 0.0
+        attribute :bp, default: 0.0
+        attribute :counter, default: 0
+        attribute :period, default: :half_period
+        attribute :peak, default: :half_period
+        attribute :real, default: :half_period
+        attribute :crosses, default: false
+        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
+        end
+
+        # alpha2 = (Cosine(.25*Bandwidth*360 / Period) +
+        #             Sine(.25*Bandwidth*360 / Period) - 1) / Cosine(.25*Bandwidth*360 / Period);
+        # HP = (1 + alpha2 / 2)*(Close - Close[1]) + (1- alpha2)*HP[1];
+        # beta = Cosine(360 / Period);
+        # gamma = 1 / Cosine(360*Bandwidth / Period);
+        # alpha = gamma - SquareRoot(gamma*gamma - 1);
+        # BP = .5*(1 - alpha)*(HP - HP[2]) + beta*(1 + alpha)*BP[1] - alpha*BP[2];
+        # If Currentbar = 1 or CurrentBar = 2 then BP = 0;
+
+        # Peak = .991*Peak;
+        # If AbsValue(BP) > If Peak <> 0 Then DC = DC[1];
+        # If DC < 6 Then DC counter = counter
+        # If Real Crosses Over 0 or Real Crosses Under 0 Then Begin
+        #   DC = 2*counter;
+        #   If 2*counter > 1.25*DC[1] Then DC = 1.25*DC[1];
+        #   If 2*counter < .8*DC[1] Then DC = .8*DC[1];
+        #   counter = 0;
+        # End;
+
+        def compute_high_pass
+          alpha = period_to_alpha(max_period, k: 0.25 * bandwidth)
+          p0.hp = (1 + alpha / 2) * (p0.input - p1.input) + (1 - alpha) * p1.hp
+        end
+
+        def compute_band_pass
+          radians = deg2rad(360.0 / max_period)
+          beta = Math.cos(radians)
+          gamma = 1.0 / Math.cos(bandwidth * radians)
+          alpha = gamma - Math.sqrt(gamma**2 - 1.0)
+
+          a = 0.5 * (1 - alpha) * (p0.hp - p2.hp)
+          b = beta * (1 + alpha) * p1.bp
+          c = alpha * p2.bp
+          p0.bp = a + b - c
+        end
+
+        def compute_period
+          p0.peak = [0.991 * p1.peak, p0.bp.abs].max
+          p0.real = p0.bp / p0.peak unless p0.peak.zero?
+          p0.counter = p1.counter + 1
+          p0.period = [p1.period, min_period].max.to_i
+          p0.crosses = (p0.real > 0.0 && p1.real < 0.0) || (p0.real < 0.0 && p1.real > 0.0)
+          if (p0.real >= 0.0 && p1.real < 0.0) || (p0.real <= 0.0 && p1.real > 0.0)
+            p0.period = [2 * p0.counter, 1.25 * p1.period].min.to_i
+            p0.period = [p0.period, 0.8 * p1.period].max.to_i
+            p0.counter = 0
+          end
+          p0.direction = p0.real > (p1.real + p2.real + p3.real) / 3.0 ? :up : :down
+        end
+
+        def compute
+          compute_high_pass
+          compute_band_pass
+          compute_period
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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 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))
+          p0.inst_period = p0.ddd > 0.01 ? 6.2832 * (p0.i2**2 + p0.q2**2) / p0.ddd : 0.0
+
+          constrain_period_magnitude_change
+          constrain_period_bars
+          p0.period = p0.inst_period.round(0).to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+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
+        attribute :detrend, default: 0.0
+        attribute :inst_period, default: :min_period
+        attribute :period, key: "p", default: nil # intentially nil! (see: compute_period)
+        attribute :smooth_period, key: "sp", default: :min_period
+        attribute :mean_period, key: "mp", default: :min_period
+        attribute :ddd, default: 0.0
+        attribute :q1, default: 0.0
+        attribute :q2, default: 0.0
+        attribute :i1, default: 0.0
+        attribute :i2, default: 0.0
+        attribute :ji, default: 0.0
+        attribute :jq, default: 0.0
+        attribute :re, default: 0.0
+        attribute :im, default: 0.0
+        attribute :phase, default: 0.0
+        attribute :phase_sum, key: "ps", default: 0.0
+        attribute :delta_phase, default: 0.0
+        attribute :accumulator_phase, default: 0.0
+        attribute :real_part, default: 0.0
+        attribute :imag_part, default: 0.0
+      end
+
+      class DominantCycle < Indicators::Indicator
+        def points_class
+          Object.const_get "Quant::Indicators::DominantCycles::#{indicator_name}Point"
+        rescue NameError
+          DominantCyclePoint
+        end
+
+        # constrain between min_period and max_period bars
+        def constrain_period_bars
+          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
+          p0.inst_period = [0.67 * p1.inst_period, p0.inst_period].max
+        end
+
+        # amplitude correction using previous period value
+        def compute_smooth_period
+          p0.inst_period = (0.2 * p0.inst_period) + (0.8 * p1.inst_period)
+          p0.smooth_period = (0.33333 * p0.inst_period) + (0.666667 * p1.smooth_period)
+        end
+
+        def compute_mean_period
+          ss_period = super_smoother(:smooth_period, previous: :mean_period, period: micro_period)
+          p0.mean_period = ss_period.clamp(min_period, max_period)
+        end
+
+        def dominant_cycle_period
+          [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
+          compute_period
+          compute_smooth_period
+          compute_mean_period
+          compute_phase
+        end
+
+        def compute_input_data_points
+          p0.smooth = wma :input
+          p0.detrend = hilbert_transform :smooth, period: p1.inst_period
+        end
+
+        # NOTE: The phase lag of q1 and `i1 is (360 * 7 / Period - 90)` degrees
+        # where Period is the dominant cycle period.
+        def compute_quadrature_components
+          # { Compute Inphase and Quadrature components }
+          p0.q1 = hilbert_transform :detrend, period: p1.inst_period
+          p0.i1 = p3.detrend
+
+          # { Advance the phase of I1 and Q1 by 90 degrees }
+          p0.ji = hilbert_transform :i1, period: p1.inst_period
+          p0.jq = hilbert_transform :q1, period: p1.inst_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))
+        end
+
+        def compute_period
+          raise NotImplementedError
+        end
+
+        def compute_phase
+          raise "must compute period before calling!" unless p0.period
+
+          period_points(dominant_cycle_period).map(&:smooth).each_with_index do |smooth, index|
+            radians = deg2rad((1 + index) * 360.0 / dominant_cycle_period)
+            p0.real_part += smooth * Math.sin(radians)
+            p0.imag_part += smooth * Math.cos(radians)
+          end
+
+          if p0.imag_part.zero?
+            p0.phase = 90.0 * (p0.real_part.positive? ? 1 : 0)
+          else
+            radians = deg2rad(p0.real_part / p0.imag_part)
+            p0.phase = rad2deg(Math.atan(radians))
+          end
+          p0.phase += 90
+          # { Compensate for one bar lag of the Weighted Moving Average }
+          p0.phase += (360.0 / p0.inst_period)
+
+          p0.phase += 180.0 if p0.imag_part < 0.0
+          p0.phase -= 360.0 if p0.phase > 315.0
+          p0.delta_phase = [1.0, p1.phase - p0.phase].max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,28 @@
+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
+      class Homodyne < DominantCycle
+        def compute_period
+          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.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
+          p0.mean_period = super_smoother :inst_period, previous: :mean_period, period: max_period
+          p0.period = p0.mean_period.round(0).to_i
+        end
+      end
+    end
+  end
+end