quantitative 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7ddfcfd200564c3ce9764a7ba635635c56649c6681ac6d76b93390734da4fc9
-  data.tar.gz: 04d93778a91c74ee4c3459009f4990644121974b77079d79a3816c5f63a63f6c
+  metadata.gz: e3db79bcbb841511c94568e330f60dfb6b68178ae874c56b867c17c538510a01
+  data.tar.gz: c5da8745035d84023886dcc8fba53f0df473c404b979e084385f6d9a7e19d536
 SHA512:
-  metadata.gz: 8facaa3efaef73c00f98f03b4482b876cf9a6155f46fb56f1c0d3534c996b6c33fefa067ee07ef8f326e76dfbdd41b0fa7d04f349eef49add179444bbe0d9db6
-  data.tar.gz: 3fa7bb3d2e34cd3f2ebd718105ab20ffb60e044c45fb5c3909a14cdd1d2876288ae23d4eb7c4211f35890ddd250772068f1c0e0463db71d1c84c490a06edc2d8
+  metadata.gz: 23c01e976533a62eddd80d5a774c55d23c644f6b9902392277f8a3450849f46a8dd8ead5588d8cc798cbaa36cce6c7ca7404ed332d4b41d6707982fb8e85c7bc
+  data.tar.gz: 769c9951b5af3cef2f9a4b93c4a49bd13f33876daa18ba90cf78a00503bfea1e87d8fa4ece964e72f0e15dbc712ef857bf3fa102d438e982d308e00a4c376b9d

data/Gemfile.lock

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

data/Guardfile

@@ -1,6 +1,6 @@
 guard :rspec, cmd: "rspec" do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^spec/lib/**/.+_spec\.rb$})
+  watch(%r{^spec/lib/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch("spec/spec_helper.rb") { "spec" }
 end

data/Rakefile

@@ -38,4 +38,9 @@ namespace :gem do
   task release: [:build, :tag] do
     sh "gem push quantitative-#{Quant::VERSION}.gem"
   end
-end
+
+  desc "push #{Quant::VERSION} to rubygems.org"
+  task push: [:build] do
+    sh "gem push quantitative-#{Quant::VERSION}.gem"
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Quant
+  module Experimental
+    def self.tracker
+      @tracker ||= {}
+    end
+  end
+
+  def self.experimental(message)
+    return if defined?(RSpec)
+    return if Experimental.tracker[caller.first]
+
+    Experimental.tracker[caller.first] = message
+
+    calling_method = caller.first.scan(/`([^']*)/)[0][0]
+    full_message = "EXPERIMENTAL: #{calling_method.inspect}: #{message}\nsource location: #{caller.first}"
+    puts full_message
+  end
+end

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