quantitative 0.1.10 → 0.2.1

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 sample we can then look backwards, adding up the delta
+      # phases.  When the sum of the delta phases reaches 360 degrees,
+      # we must have passed through one full cycle, on average.  The process
+      # is repeated for each new sample.
+      #
+      # 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
 
@@ -21,9 +19,42 @@ module Quant
         @series = series
         @source = source
         @points = {}
+        series.new_indicator(self)
         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 dominant_cycle
+        series.indicators[source].dominant_cycle
+      end
+
+      def dc_period
+        dominant_cycle.points[t0].period
+      end
+
       def ticks
         @points.keys
       end
@@ -45,7 +76,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

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

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

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

data/lib/quant/settings/indicators.rb

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

data/lib/quant/settings.rb

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

data/lib/quant/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.1"
 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.1
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-03 00:00:00.000000000 Z
+date: 2024-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -51,9 +51,16 @@ 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/half_period.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 +83,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