quantitative 0.1.9 → 0.2.0

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
@@ -64,7 +86,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} symbol=#{series.symbol} source=#{source} #{ticks.size} ticks>"
+        "#<#{self.class.name} symbol=#{series.symbol} source=#{source} ticks=#{ticks.size}>"
       end
 
       def compute

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

@@ -116,10 +116,6 @@ module Quant
       "1D"  => :daily,
     }.freeze
 
-    def self.all_resolutions
-      RESOLUTIONS.keys
-    end
-
     # Instantiates an Interval from a resolution.  For example, TradingView uses resolutions
     # like "1", "3", "5", "15", "30", "60", "240", "D", "1D" to represent the duration of a
     # candlestick.  +from_resolution+ translates resolutions to the appropriate {Quant::Interval}.
@@ -216,6 +212,11 @@ module Quant
       INTERVAL_DISTANCE.keys
     end
 
+    # Returns the full list of valid resolution Strings that can be used to instantiate an {Quant::Interval}.
+    def self.all_resolutions
+      RESOLUTIONS.keys
+    end
+
     # Computes the number of ticks from present to given timestamp.
     # If timestamp doesn't cover a full interval, it will be rounded up to 1
     # @example
@@ -230,7 +231,7 @@ module Quant
     end
 
     def self.ensure_valid_resolution!(resolution)
-      return if RESOLUTIONS.keys.include? resolution
+      return if all_resolutions.include? resolution
 
       should_be_one_of = "Should be one of: (#{RESOLUTIONS.keys.join(", ")})"
       raise Errors::InvalidResolution, "resolution (#{resolution}) not a valid resolution. #{should_be_one_of}"
@@ -248,10 +249,6 @@ module Quant
       should_be_one_of = "Should be one of: (#{valid_intervals.join(", ")})"
       raise Errors::InvalidInterval, "interval (#{interval.inspect}) not a valid interval. #{should_be_one_of}"
     end
-
-    def ensure_valid_resolution!(resolution)
-      self.class.ensure_valid_resolution!(resolution)
-    end
   end
 end
 # rubocop:enable Layout/HashAlignment

data/lib/quant/mixins/filters.rb

@@ -1,51 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "high_pass_filters"
+require_relative "butterworth_filters"
+require_relative "universal_filters"
 module Quant
   module Mixins
-    # 1.  All the common filters useful for traders have a transfer response
-    #     that can be written as a ratio of two polynomials.
-    # 2.  Lag is very important to traders. More complex filters can be
-    #     created using more input data, but more input data increases lag.
-    #     Sophisticated filters are not very useful for trading because they
-    #     incur too much lag.
-    # 3.  Filter transfer response can be viewed in the time domain and
-    #     the frequency domain with equal validity.
-    # 4.  Nonrecursive filters can have zeros in the transfer response, enabling
-    #     the complete cancellation of some selected frequency components.
-    # 5.  Nonrecursive filters having coefficients symmetrical about the
-    #     center of the filter will have a delay of half the degree of the
-    #     transfer response polynomial at all frequencies.
-    # 6.  Low-pass filters are smoothers because they attenuate the high-frequency
-    #     components of the input data.
-    # 7.  High-pass filters are detrenders because they attenuate the
-    #     low-frequency components of trends.
-    # 8.  Band-pass filters are both detrenders and smoothers because they
-    #     attenuate all but the desired frequency components.
-    # 9.  Filters provide an output only through their transfer response.
-    #     The transfer response is strictly a mathematical function, and
-    #     interpretations such as overbought, oversold, convergence, divergence,
-    #     and so on are not implied. The validity of such interpretations
-    #     must be made on the basis of statistics apart from the filter.
-    # 10. The critical period of a filter output is the frequency at which
-    #     the output power of the filter is half the power of the input
-    #     wave at that frequency.
-    # 11. A WMA has little or no redeeming virtue.
-    # 12. A median filter is best used when the data contain impulsive noise
-    #     or when there are wild variations in the data. Smoothing volume
-    #     data is one example of a good application for a median filter.
-    #
-    # == Filter Coefficients forVariousTypes of Filters
-    #
-    #   Filter Type           b0          b1              b2          a0        a1        a2
-    #   EMA                   α           0               0           1         −(1−α)    0
-    #   Two-pole low-pass     α**2        0               0           1         −2*(1-α)  (1-α)**2
-    #   High-pass             (1-α/2)     -(1-α/2)        0           1         −(1−α)    0
-    #   Two-pole high-pass    (1-α/2)**2  -2*(1-α/2)**2   (1-α/2)**2  1         -2*(1-α)  (1-α)**2
-    #   Band-pass             (1-σ)/2     0               -(1-σ)/2    1         -λ*(1+σ)  σ
-    #   Band-stop             (1+σ)/2     -2λ*(1+σ)/2     (1+σ)/2     1         -λ*(1+σ)  σ
-    #
     module Filters
+      include Mixins::HighPassFilters
       include Mixins::ButterworthFilters
+      include Mixins::UniversalFilters
     end
   end
 end

data/lib/quant/mixins/functions.rb

@@ -8,7 +8,7 @@ module Quant
       # k = 0.707 for two-pole high-pass filters
       # k = 1.414 for two-pole low-pass filters
       def period_to_alpha(period, k: 1.0)
-        radians = deg2rad(k * 360 / period)
+        radians = deg2rad(k * 360 / period.to_f)
         cos = Math.cos(radians)
         sin = Math.sin(radians)
         (cos + sin - 1) / cos
@@ -48,8 +48,12 @@ module Quant
         dy2 = line2[1][1] - line1[1][1]
 
         d = dx1 * dx2 + dy1 * dy2
-        l2 = (dx1**2 + dy1**2) * (dx2**2 + dy2**2)
-        rad2deg Math.acos(d / Math.sqrt(l2))
+        l2 = ((dx1**2 + dy1**2) * (dx2**2 + dy2**2))
+
+        radians = d.to_f / Math.sqrt(l2)
+        value = rad2deg Math.acos(radians)
+
+        value.nan? ? 0.0 : value
       end
 
       # angle = acos(d/sqrt(l2))

data/lib/quant/mixins/high_pass_filters.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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
+      # 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)
+
+        alpha = period_to_alpha(period, k: 0.707)
+
+        v1 = p0.send(source) - (2.0 * p1.send(source)) + p2.send(source)
+        v2 = p1.send(previous)
+        v3 = p2.send(previous)
+
+        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)
+        raise ArgumentError, "previous must be a Symbol" unless previous.is_a?(Symbol)
+
+        radians = Math.sqrt(2) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+
+        c2 = b
+        c3 = -a**2
+        c1 = (1 + c2 - c3) / 4
+
+        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
+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.0r * 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