quantitative 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50dde4546ee2c241a00695bf5928fb76c92a7323e8b1a2d5d0090db74bbebee5
-  data.tar.gz: f6432d642ac5111cd4fe0cb6b041ada60af39ba41033195c949b0126184ae180
+  metadata.gz: e3db79bcbb841511c94568e330f60dfb6b68178ae874c56b867c17c538510a01
+  data.tar.gz: c5da8745035d84023886dcc8fba53f0df473c404b979e084385f6d9a7e19d536
 SHA512:
-  metadata.gz: d48777cee5009e48b5d3ef6c531029fdaa8c9629b37223ad919aacd53c29caf13258d7cddc28413788b61ec086af0abde606996cdac3c7012565ec2cea5b6e77
-  data.tar.gz: 8c9fa61a0f4b4c21b890c6895d4e74ba870fb92336cd30bb822e13bad5e49e9ee8d4b45e639171a73ab8c04e1756088e79979231a557a41ad9effa8ee1660e6b
+  metadata.gz: 23c01e976533a62eddd80d5a774c55d23c644f6b9902392277f8a3450849f46a8dd8ead5588d8cc798cbaa36cce6c7ca7404ed332d4b41d6707982fb8e85c7bc
+  data.tar.gz: 769c9951b5af3cef2f9a4b93c4a49bd13f33876daa18ba90cf78a00503bfea1e87d8fa4ece964e72f0e15dbc712ef857bf3fa102d438e982d308e00a4c376b9d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.1.10)
+    quantitative (0.2.0)
       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/indicators/dominant_cycle_indicators.rb

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

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
+      class Acr < DominantCycle
+        def average_length
+          3 # AvgLength
+        end
+
+        def bandwidth
+          deg2rad(370)
+        end
+
+        def compute_auto_correlations
+          (min_period..max_period).each do |period|
+            corr = Statistics::Correlation.new
+            average_length.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|
+            (average_length..max_period).each do |n|
+              radians = bandwidth * 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,80 @@
+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
+
+      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,19 @@
+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.
+      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,128 @@
+require_relative "../indicator"
+
+module Quant
+  class Indicators
+    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
+
+        # 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/homodyne.rb

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

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

@@ -0,0 +1,59 @@
+require_relative "dominant_cycle"
+
+module Quant
+  class Indicators
+    class DominantCycles
+      # The phase accumulation method of computing the dominant cycle is perhaps
+      # the easiest to comprehend. In this technique, we measure the phase
+      # 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
+      # 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.
+      #
+      # The phase accumulation method of cycle measurement always uses one
+      # full cycle’s worth of historical data. This is both an advantage
+      # and a disadvantage.  The advantage is the lag in obtaining the answer
+      # scales directly with the cycle period.  That is, the measurement of
+      # a short cycle period has less lag than the measurement of a longer
+      # cycle period. However, the number of samples used in making the
+      # measurement means the averaging period is variable with cycle period.
+      # Longer averaging reduces the noise level compared to the signal.
+      # Therefore, shorter cycle periods necessarily have a higher output
+      # signal-to-noise ratio.
+      class PhaseAccumulator < DominantCycle
+        def compute_period
+          p0.i1 = 0.15 * p0.i1 + 0.85 * p1.i1
+          p0.q1 = 0.15 * p0.q1 + 0.85 * p1.q1
+
+          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
+          end
+
+          p0.delta_phase = p1.accumulator_phase - p0.accumulator_phase
+          if p1.accumulator_phase < 90.0 && p0.accumulator_phase > 270.0
+            p0.delta_phase = 360.0 + p1.accumulator_phase - p0.accumulator_phase
+          end
+
+          p0.delta_phase = p0.delta_phase.clamp(min_period, max_period)
+
+          p0.inst_period = p1.inst_period
+          period_points(max_period).each_with_index do |prev, index|
+            p0.phase_sum += prev.delta_phase
+            if p0.phase_sum > 360.0
+              p0.inst_period = index
+              break
+            end
+          end
+          p0.period = (0.25 * p0.inst_period + 0.75 * p1.inst_period).round(0)
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/indicator.rb

@@ -7,13 +7,11 @@ module Quant
       include Mixins::Functions
       include Mixins::Filters
       include Mixins::MovingAverages
-      # include Mixins::HilbertTransform
-      # include Mixins::SuperSmoother
-      # include Mixins::Stochastic
-      # include Mixins::FisherTransform
-      # include Mixins::HighPassFilter
+      include Mixins::HilbertTransform
+      include Mixins::SuperSmoother
+      include Mixins::Stochastic
+      include Mixins::FisherTransform
       # include Mixins::Direction
-      # include Mixins::Filters
 
       attr_reader :source, :series
 
@@ -24,6 +22,30 @@ module Quant
         series.each { |tick| self << tick }
       end
 
+      def min_period
+        Quant.config.indicators.min_period
+      end
+
+      def max_period
+        Quant.config.indicators.max_period
+      end
+
+      def half_period
+        Quant.config.indicators.half_period
+      end
+
+      def micro_period
+        Quant.config.indicators.micro_period
+      end
+
+      def dominant_cycle_kind
+        Quant.config.indicators.dominant_cycle_kind
+      end
+
+      def pivot_kind
+        Quant.config.indicators.pivot_kind
+      end
+
       def ticks
         @points.keys
       end
@@ -45,7 +67,7 @@ module Quant
 
       def <<(tick)
         @t0 = tick
-        @p0 = points_class.new(tick:, source:)
+        @p0 = points_class.new(indicator: self, tick:, source:)
         @points[tick] = @p0
 
         @p1 = values[-2] || @p0

data/lib/quant/indicators/indicator_point.rb

@@ -4,19 +4,29 @@ module Quant
   class Indicators
     class IndicatorPoint
       include Quant::Attributes
+      extend Forwardable
 
-      attr_reader :tick
+      attr_reader :indicator, :tick
 
       attribute :source, key: "src"
       attribute :input, key: "in"
 
-      def initialize(tick:, source:)
+      def initialize(indicator:, tick:, source:)
+        @indicator = indicator
         @tick = tick
         @source = source
         @input = @tick.send(source)
         initialize_data_points
       end
 
+      def_delegator :indicator, :series
+      def_delegator :indicator, :min_period
+      def_delegator :indicator, :max_period
+      def_delegator :indicator, :half_period
+      def_delegator :indicator, :micro_period
+      def_delegator :indicator, :dominant_cycle_kind
+      def_delegator :indicator, :pivot_kind
+
       def initialize_data_points
         # No-Op - Override in subclass if needed.
       end

data/lib/quant/indicators.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "indicators_proxy"
 module Quant
-  # TODO: build an Indicator registry so new indicators can be added and used outside those shipped with the library.
-  class Indicators
+  # TODO: build an Indicator registry so new indicators can be added and
+  #       used outside those shipped with the library.
+  class Indicators < IndicatorsProxy
+    def ping; indicator(Indicators::Ping) end
+
+    def dominant_cycles
+      @dominant_cycles ||= Indicators::DominantCycleIndicators.new(series:, source:)
+    end
   end
 end

data/lib/quant/indicators_proxy.rb

@@ -54,8 +54,5 @@ module Quant
     def attach(name:, indicator_class:)
       define_singleton_method(name) { indicator(indicator_class) }
     end
-
-    def ma; indicator(Indicators::Ma) end
-    def ping; indicator(Indicators::Ping) end
   end
 end

data/lib/quant/indicators_sources.rb

@@ -12,7 +12,7 @@ module Quant
     end
 
     def oc2
-      @indicator_sources[:oc2] ||= IndicatorsProxy.new(series: @series, source: :oc2)
+      @indicator_sources[:oc2] ||= Indicators.new(series: @series, source: :oc2)
     end
   end
 end

data/lib/quant/mixins/high_pass_filters.rb

@@ -2,44 +2,89 @@
 
 module Quant
   module Mixins
+    # The following are high pass filters that are used to remove low frequency
+    # components from a time series. In simple terms, a high pass filter
+    # allows signals above a certain frequency (the cutoff frequency) to
+    # pass through relatively unaffected, while attenuating or blocking
+    # signals below that frequency.
+    #
+    # HighPass Filters are “detrenders” because they attenuate low frequency components
+    # One pole HighPass and SuperSmoother does not produce a zero mean because low
+    # frequency spectral dilation components are "leaking" through The one pole
+    # HighPass Filter response
+    #
+    # == Experimental
+    # Across the various texts and papers, Ehlers presents varying implementations
+    # of high-pass filters.  I believe the two pole high-pass filter is the most
+    # consistently presented while the one pole high-pass filter has been presented
+    # in a few different ways.  In some implementations, alpha is based on simple
+    # bars/lag while others use alpha based on phase/trigonometry.  I have not been
+    # able to reconcile the differences and have not been able to find a definitive
+    # source for the correct implementation and do not know enough math to reason
+    # these out mathematically nor do I possess an advanced understanding of the
+    # fundamentals around digital signal processing.  As such, the single-pole
+    # high-pass filters in this module are marked as experimental and may be incorrect.
     module HighPassFilters
-      # HighPass Filters are “detrenders” because they attenuate low frequency components
-      # One pole HighPass and SuperSmoother does not produce a zero mean because low
-      # frequency spectral dilation components are “leaking” through The one pole
-      # HighPass Filter response
-      def two_pole_high_pass_filter(source, prev_source, min_period, max_period = nil)
-        raise "source must be a symbol" unless source.is_a?(Symbol)
-        return p0.send(source) if p0 == p2
-
-        max_period ||= min_period * 2
-        (min_period * Math.sqrt(2))
-        max_radians = 2.0 * Math::PI / (max_period * Math.sqrt(2))
+      # A two-pole high-pass filter is a more advanced filtering technique
+      # used to remove low-frequency components from financial time series
+      # data, such as stock prices or market indices.
+      #
+      # Similar to a single-pole high-pass filter, a two-pole high-pass filter
+      # is designed to attenuate or eliminate slow-moving trends or macroeconomic
+      # effects from the data while preserving higher-frequency fluctuations.
+      # However, compared to the single-pole filter, the two-pole filter
+      # typically offers a steeper roll-off and better attenuation of lower
+      # frequencies, resulting in a more pronounced emphasis on short-term fluctuations.
+      def two_pole_high_pass_filter(source, period:, previous: :hp)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+        raise ArgumentError, "previous must be a Symbol" unless previous.is_a?(Symbol)
 
-        v1 = p0.send(source) - (2.0 * p1.send(source)) + p2.send(source)
-        v2 = p1.send(prev_source)
-        v3 = p2.send(prev_source)
+        alpha = period_to_alpha(period, k: 0.707)
 
-        alpha = period_to_alpha(max_radians)
+        v1 = p0.send(source) - (2.0 * p1.send(source)) + p2.send(source)
+        v2 = p1.send(previous)
+        v3 = p2.send(previous)
 
-        a = (1 - (alpha * 0.5))**2 * v1
-        b = 2 * (1 - alpha) * v2
-        c = (1 - alpha)**2 * v3
+        a = v1 * (1 - (alpha * 0.5))**2
+        b = v2 * 2 * (1 - alpha)
+        c = v3 * (1 - alpha)**2
 
         a + b - c
       end
 
+      # A single-pole high-pass filter is used to filter out low-frequency
+      # components from financial time series data. This type of filter is
+      # commonly applied in signal processing techniques to remove noise or
+      # unwanted trends from the data while preserving higher-frequency fluctuations.
+      #
+      # A single-pole high-pass filter can be used to remove slow-moving trends
+      # or macroeconomic effects from the data, focusing instead on short-term
+      # fluctuations or high-frequency trading signals. By filtering out
+      # low-frequency components, traders aim to identify and exploit more
+      # immediate market opportunities, such as short-term price movements
+      # or momentum signals.
+      #
+      # The implementation of a single-pole high-pass filter in algorithmic
+      # trading typically involves applying a mathematical formula or algorithm
+      # to the historical price data of a financial instrument. This algorithm
+      # selectively attenuates or removes the low-frequency components of the
+      # data, leaving behind the higher-frequency fluctuations that traders
+      # are interested in analyzing for potential trading signals.
+      #
+      # Overall, single-pole high-pass filters in algorithmic trading are
+      # used as preprocessing steps to enhance the signal-to-noise ratio in
+      # financial data and to extract actionable trading signals from noisy
+      # or cluttered market data.
+      #
+      # == NOTES
       # alpha = (Cosine(.707* 2 * PI / 48) + Sine (.707*360 / 48) - 1) / Cosine(.707*360 / 48);
       # is the same as the following:
       # radians = Math.sqrt(2) * Math::PI / period
       # alpha = (Math.cos(radians) + Math.sin(radians) - 1) / Math.cos(radians)
       def high_pass_filter(source, period:, previous: :hp)
+        Quant.experimental("This method is unproven and may be incorrect.")
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
-
-        v0 = p0.send(source)
-        return v0 if p3 == p0
-
-        v1 = p1.send(source)
-        v2 = p2.send(source)
+        raise ArgumentError, "previous must be a Symbol" unless previous.is_a?(Symbol)
 
         radians = Math.sqrt(2) * Math::PI / period
         a = Math.exp(-radians)
@@ -49,7 +94,35 @@ module Quant
         c3 = -a**2
         c1 = (1 + c2 - c3) / 4
 
-        (c1 * (v0 - (2 * v1) + v2)) + (c2 * p1.hp) + (c3 * p2.hp)
+        v0 = p0.send(source)
+        v1 = p1.send(source)
+        v2 = p2.send(source)
+        f1 = p1.send(previous)
+        f2 = p2.send(previous)
+
+        (c1 * (v0 - (2 * v1) + v2)) + (c2 * f1) + (c3 * f2)
+      end
+
+      # HPF = (1 − α/2)2 * (Price − 2 * Price[1] + Price[2]) + 2 * (1 − α) * HPF[1] − (1 − α)2 * HPF[2];
+      # High Pass Filter presented in Ehlers Cybernetic Analysis for Stocks and Futures Equation 2.7
+      def hpf2(source, period:, previous:)
+        Quant.experimental("This method is unproven and may be incorrect.")
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+        raise ArgumentError, "previous must be a Symbol" unless previous.is_a?(Symbol)
+
+        alpha = period_to_alpha(period, k: 1.0)
+        v0 = p0.send(source)
+        v1 = p1.send(source)
+        v2 = p1.send(source)
+
+        f1 = p1.send(previous)
+        f2 = p2.send(previous)
+
+        c1 = (1 - alpha / 2)**2
+        c2 = 2 * (1 - alpha)
+        c3 = (1 - alpha)**2
+
+        (c1 * (v0 - (2 * v1) + v2)) + (c2 * f1) - (c3 * f2)
       end
     end
   end

data/lib/quant/mixins/super_smoother.rb

@@ -6,39 +6,42 @@ module Quant
       def two_pole_super_smooth(source, period:, previous: :ss)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
-        radians = Math::PI * Math.sqrt(2) / period
+        radians = Math.sqrt(2) * Math::PI / period
         a1 = Math.exp(-radians)
 
-        coef2 = 2.0 * a1 * Math.cos(radians)
-        coef3 = -a1 * a1
-        coef1 = 1.0 - coef2 - coef3
+        c3 = -a1**2
+        c2 = 2.0 * a1 * Math.cos(radians)
+        c1 = 1.0 - c2 - c3
 
-        v0 = (p0.send(source) + p1.send(source)) / 2.0
-        v1 = p2.send(previous)
-        v2 = p3.send(previous)
-        ((coef1 * v0) + (coef2 * v1) + (coef3 * v2)).to_f
+        v1 = (p0.send(source) + p1.send(source)) * 0.5
+        v2 = p2.send(previous)
+        v3 = p3.send(previous)
+
+        (c1 * v1) + (c2 * v2) + (c3 * v3)
       end
+
       alias super_smoother two_pole_super_smooth
       alias ss2p two_pole_super_smooth
 
       def three_pole_super_smooth(source, period:, previous: :ss)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
-        a1 = Math.exp(-Math::PI / period)
-        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / period)
+        radians = Math::PI / period
+        a1 = Math.exp(-radians)
+        b1 = 2 * a1 * Math.cos(Math.sqrt(3) * radians)
         c1 = a1**2
 
-        coef2 = b1 + c1
-        coef3 = -(c1 + b1 * c1)
-        coef4 = c1**2
-        coef1 = 1 - coef2 - coef3 - coef4
+        c4 = c1**2
+        c3 = -(c1 + b1 * c1)
+        c2 = b1 + c1
+        c1 = 1 - c2 - c3 - c4
 
         v0 = p0.send(source)
         v1 = p1.send(previous)
         v2 = p2.send(previous)
         v3 = p3.send(previous)
 
-        (coef1 * v0) + (coef2 * v1) + (coef3 * v2) + (coef4 * v3)
+        (c1 * v0) + (c2 * v1) + (c3 * v2) + (c4 * v3)
       end
       alias ss3p three_pole_super_smooth
     end

data/lib/quant/mixins/universal_filters.rb

@@ -16,6 +16,20 @@ module Quant
     # the others are still unproven and Ehlers' many papers over the year
     # tend to change implementation details, too.
     #
+    # == Experimental!
+    # The main goal with the universal filters is to provide a means to
+    # compare the optimized filters with the generalized filters and
+    # generally show correctness of the solutions.  However, that also
+    # means validating the outputs of those computations, which is not my forté.
+    # My idea of validating is if I have two or more implementations that produce
+    # identical (or nearly identical) results, then I consider the implementation
+    # sound and doing what it is supposed to do.
+    #
+    # Several are marked "experimental" because I have not been able to
+    # prove their correctness.  Those that are proven correct are not
+    # marked as experimental and you'll find their outputs show up in other
+    # specs where they're used alongside the optimized versions of those filters.
+    #
     # == Ehlers' Notes on Generalized Filters
     # 1.  All the common filters useful for traders have a transfer response
     #     that can be written as a ratio of two polynomials.
@@ -272,7 +286,6 @@ module Quant
       # not be suitable for all trading or analysis purposes, and its effects
       # should be evaluated in the context of specific goals and strategies.
       def universal_two_pole_high_pass(source, previous:, period:)
-        Quant.experimental("This method is unproven and may be incorrect.")
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
         raise ArgumentError, ":previous must be a Symbol" unless previous.is_a?(Symbol)
 

data/lib/quant/statistics/correlation.rb

@@ -0,0 +1,37 @@
+module Quant
+  module Statistics
+    class Correlation
+      attr_accessor :length, :sx, :sy, :sxx, :sxy, :syy
+
+      def initialize
+        @length = 0.0
+        @sx = 0.0
+        @sy = 0.0
+        @sxx = 0.0
+        @sxy = 0.0
+        @syy = 0.0
+      end
+
+      def add(x, y)
+        @length += 1
+        @sx += x
+        @sy += y
+        @sxx += x * x
+        @sxy += x * y
+        @syy += y * y
+      end
+
+      def devisor
+        value = (length * sxx - sx**2) * (length * syy - sy**2)
+        value.zero? ? 1.0 : value
+      end
+
+      def coefficient
+        (length * sxy - sx * sy) / Math.sqrt(devisor)
+      rescue Math::DomainError
+        0.0
+      end
+    end
+  end
+end
+

data/lib/quant/version.rb

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

data/lib/quantitative.rb

@@ -12,6 +12,6 @@ quant_folder = File.join(lib_folder, "quant")
 Dir.glob(File.join(quant_folder, "*.rb")).each { |fn| require fn }
 
 # require sub-folders and their sub-folders
-%w(refinements mixins settings ticks indicators).each do |sub_folder|
+%w(refinements mixins statistics settings ticks indicators).each do |sub_folder|
   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-03 00:00:00.000000000 Z
+date: 2024-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -51,9 +51,15 @@ files:
 - lib/quant/errors.rb
 - lib/quant/experimental.rb
 - lib/quant/indicators.rb
+- lib/quant/indicators/dominant_cycle_indicators.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/homodyne.rb
+- lib/quant/indicators/dominant_cycles/phase_accumulator.rb
 - lib/quant/indicators/indicator.rb
 - lib/quant/indicators/indicator_point.rb
-- lib/quant/indicators/ma.rb
 - lib/quant/indicators/ping.rb
 - lib/quant/indicators_proxy.rb
 - lib/quant/indicators_sources.rb
@@ -76,6 +82,7 @@ files:
 - lib/quant/series.rb
 - lib/quant/settings.rb
 - lib/quant/settings/indicators.rb
+- lib/quant/statistics/correlation.rb
 - lib/quant/ticks/ohlc.rb
 - lib/quant/ticks/serializers/ohlc.rb
 - lib/quant/ticks/serializers/spot.rb

data/lib/quant/indicators/ma.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Quant
-  class Indicators
-    class MaPoint < IndicatorPoint
-      attribute :ss, key: "ss"
-      attribute :ema, key: "ema"
-      attr_accessor :ss, :ema, :osc
-
-      def initialize_data_points
-        @ss = input
-        @ema = input
-        @osc = nil
-      end
-    end
-
-    # Moving Averages
-    class Ma < Indicator
-      include Quant::Mixins::Filters
-
-      def alpha(period)
-        bars_to_alpha(period)
-      end
-
-      def min_period
-        8 # Quant.config.indicators.min_period
-      end
-
-      def max_period
-        48 # Quant.config.indicators.max_period
-      end
-
-      def compute
-        # p0.ss = super_smoother input, :ss, min_period
-        p0.ema = alpha(max_period) * input + (1 - alpha(max_period)) * p1.ema
-        p0.osc = p0.ss - p0.ema
-      end
-    end
-  end
-end