quantitative 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7ddfcfd200564c3ce9764a7ba635635c56649c6681ac6d76b93390734da4fc9
-  data.tar.gz: 04d93778a91c74ee4c3459009f4990644121974b77079d79a3816c5f63a63f6c
+  metadata.gz: 50dde4546ee2c241a00695bf5928fb76c92a7323e8b1a2d5d0090db74bbebee5
+  data.tar.gz: f6432d642ac5111cd4fe0cb6b041ada60af39ba41033195c949b0126184ae180
 SHA512:
-  metadata.gz: 8facaa3efaef73c00f98f03b4482b876cf9a6155f46fb56f1c0d3534c996b6c33fefa067ee07ef8f326e76dfbdd41b0fa7d04f349eef49add179444bbe0d9db6
-  data.tar.gz: 3fa7bb3d2e34cd3f2ebd718105ab20ffb60e044c45fb5c3909a14cdd1d2876288ae23d4eb7c4211f35890ddd250772068f1c0e0463db71d1c84c490a06edc2d8
+  metadata.gz: d48777cee5009e48b5d3ef6c531029fdaa8c9629b37223ad919aacd53c29caf13258d7cddc28413788b61ec086af0abde606996cdac3c7012565ec2cea5b6e77
+  data.tar.gz: 8c9fa61a0f4b4c21b890c6895d4e74ba870fb92336cd30bb822e13bad5e49e9ee8d4b45e639171a73ab8c04e1756088e79979231a557a41ad9effa8ee1660e6b

data/Gemfile.lock

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

@@ -64,7 +64,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/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_filter.rb → high_pass_filters.rb}

@@ -2,7 +2,7 @@
 
 module Quant
   module Mixins
-    module HighPassFilter
+    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
@@ -32,8 +32,10 @@ module Quant
       # 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)
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+      def high_pass_filter(source, period:, previous: :hp)
+        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)

data/lib/quant/mixins/super_smoother.rb

@@ -9,7 +9,7 @@ module Quant
         radians = Math::PI * Math.sqrt(2) / period
         a1 = Math.exp(-radians)
 
-        coef2 = 2.0r * a1 * Math.cos(radians)
+        coef2 = 2.0 * a1 * Math.cos(radians)
         coef3 = -a1 * a1
         coef1 = 1.0 - coef2 - coef3
 

data/lib/quant/mixins/universal_filters.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    # Source: Ehlers, J. F. (2013). Cycle Analytics for Traders:
+    #         Advanced Technical Trading Concepts. John Wiley & Sons.
+    #
+    # == Universal Filters
+    # Ehlers devoted a chapter in his book to generalizing the algorithms
+    # for the most common filters used in trading. The universal filters
+    # makes an attempt to translate that work into working code.  However,
+    # Ehler write up contained some typos and incomplete treatment of the
+    # subject matter, and as a non-mathematician, I am not sure if I have
+    # translated the formulas correctly.  So far, I have not been able to
+    # prove correctness of the universal EMA vs. the optimzed EMA, but
+    # the others are still unproven and Ehlers' many papers over the year
+    # tend to change implementation details, too.
+    #
+    # == 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.
+    # 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          a1        a2
+    #   EMA                   α           0               0           −(1−α)    0
+    #   Two-pole low-pass     α**2        0               0           −2*(1-α)  (1-α)**2
+    #   High-pass             (1-α/2)     -(1-α/2)        0           −(1−α)    0
+    #   Two-pole high-pass    (1-α/2)**2  -2*(1-α/2)**2   (1-α/2)**2  -2*(1-α)  (1-α)**2
+    #   Band-pass             (1-σ)/2     0               -(1-σ)/2    -λ*(1+σ)  σ
+    #   Band-stop             (1+σ)/2     -2λ*(1+σ)/2     (1+σ)/2     -λ*(1+σ)  σ
+    #
+    module UniversalFilters
+      K = {
+        single_pole: 1.0,
+        two_pole_high_pass: Math.sqrt(2) * 0.5,
+        two_pole_low_pass: Math.sqrt(2)
+      }.freeze
+
+      # The universal filter is a generalization of the common filters.  The other
+      # algorithms in this module are derived from this one.
+      def universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+        b0 * p0.send(source) +
+          b1 * p1.send(source) +
+          b2 * p2.send(source) -
+          a1 * p1.send(previous) -
+          a2 * p2.send(previous)
+      end
+
+      # The EMA is optimized in the {Quant::Mixins::ExponentialMovingAverage} module
+      # and its correctness is proven with this particular implementation.
+      def universal_ema(source, previous:, period:)
+        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 = bars_to_alpha(period)
+        b0 = alpha
+        b1 = 0
+        b2 = 0
+        a1 = -(1 - alpha)
+        a2 = 0
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+
+      # The two-pole low-pass filter can serve several purposes:
+      #
+      # 1. Noise Reduction: Stock price data often contains high-frequency
+      #    fluctuations or noise due to market volatility, algorithmic
+      #    trading, or other factors. By applying a low-pass filter, you can
+      #    smooth out these fluctuations, making it easier to identify
+      #    underlying trends or patterns in the price action.
+      # 2. Trend Identification: Low-pass filtering can help in identifying
+      #    the underlying trend in stock price movements by removing short-term
+      #    fluctuations and emphasizing longer-term movements. This can be
+      #    useful for trend-following strategies or identifying potential
+      #    trend reversals.
+      # 3. Signal Smoothing: Filtering can help in removing erratic or
+      #    spurious movements in the price data, providing a clearer and
+      #    more consistent representation of the overall price action.
+      # 4. Highlighting Structural Changes: Filtering can make structural
+      #    changes in the price action more apparent by reducing noise and
+      #    focusing on significant movements. This can be useful for detecting
+      #    shifts in market sentiment or the emergence of new trends.
+      # 5. Trade Signal Generation: Smoothed price data from a low-pass filter
+      #    can be used as input for trading strategies, such as moving
+      #    average-based strategies or momentum strategies, where identifying
+      #    trends or momentum is crucial.
+      def universal_two_pole_low_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)
+
+        alpha = period_to_alpha(period, k: K[:two_pole_low_pass] )
+        b0 = alpha**2
+        b1 = 0
+        b2 = 0
+        a1 = -2.0 * (1.0 - alpha)
+        a2 = (1.0 - alpha)**2
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+
+      # A single-pole low-pass filter, also known as a first-order low-pass
+      # filter, has a simpler response compared to a two-pole low-pass filter.
+      # It attenuates higher-frequency components of the signal while allowing
+      # lower-frequency components to pass through, but it does so with a
+      # gentler roll-off compared to higher-order filters.
+      #
+      # Here's what a single-pole low-pass filter typically does to stock
+      # price action data:
+      # 1. Noise Reduction: Similar to a two-pole low-pass filter, a single-pole
+      #    filter can help in reducing high-frequency noise in stock price data,
+      #    smoothing out rapid fluctuations caused by market volatility or other factors.
+      # 2. Trend Identification: It can aid in identifying trends by smoothing
+      #    out short-term fluctuations, making the underlying trend more apparent.
+      #    However, compared to higher-order filters, it may not provide as
+      #    sharp or accurate trend signals.
+      # 3. Signal Smoothing: Single-pole filters provide a basic level of signal
+      #    smoothing, which can help in removing minor fluctuations and emphasizing
+      #    larger movements in the price action. This can make the data easier to
+      #    interpret and analyze.
+      # 4. Delay and Responsiveness: Single-pole filters introduce less delay
+      #    compared to higher-order filters, making them more responsive to changes
+      #    in the input signal. However, this responsiveness comes at the cost of a
+      #    less aggressive attenuation of high-frequency noise.
+      # 5. Simple Filtering: Single-pole filters are computationally efficient and
+      #    easy to implement, making them suitable for real-time processing and
+      #    applications where simplicity is preferred.
+      #
+      # Overall, while a single-pole low-pass filter can still be effective for
+      # noise reduction and basic trend identification in stock price action data,
+      # it may not offer the same level of precision and robustness as higher-order
+      # filters. The choice between single-pole and higher-order filters depends on
+      # the specific requirements of the analysis and the trade-offs between
+      # responsiveness and noise attenuation.
+      def universal_one_pole_low_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)
+
+        alpha = period_to_alpha(period, k: K[:single_pole])
+        b0 = alpha
+        b1 = 0
+        b2 = 0
+        a1 = -(1 - alpha)
+        a2 = 0
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+
+      # A single-pole high-pass filter, also known as a first-order high-pass
+      # filter, attenuates low-frequency components of a signal while allowing
+      # higher-frequency components to pass through. In the context of processing
+      # stock price action data, applying a single-pole high-pass filter has
+      # several potential effects:
+      #
+      # 1. Removal of Low-Frequency Trends: Similar to higher-order high-pass
+      #    filters, a single-pole high-pass filter removes or attenuates slow-moving
+      #    components of the price action data, such as long-term trends. This can
+      #    help in focusing on shorter-term fluctuations and identifying short-term
+      #    trading opportunities.
+      # 2. Noise Amplification: As with higher-order high-pass filters, a single-pole
+      #    high-pass filter can amplify high-frequency noise present in the data,
+      #    especially if the cutoff frequency is set too low. This noise amplification
+      #    can make it challenging to analyze the data accurately, particularly if the
+      #    noise overwhelms the signal of interest.
+      # 3. Emphasis on Short-Term Variations: By removing low-frequency components, a
+      #    single-pole high-pass filter highlights short-term variations and rapid
+      #    movements in the price action data. This can be beneficial for traders or
+      #    analysts who are primarily interested in short-term price dynamics or
+      #    intraday trading opportunities.
+      # 4. Simple Filtering: Single-pole filters are computationally efficient and
+      #    straightforward to implement, making them suitable for real-time processing
+      #    and applications where simplicity is preferred. However, they may not offer
+      #    the same level of noise attenuation and signal preservation as higher-order
+      #    filters.
+      # 5. Enhanced Responsiveness: Single-pole high-pass filters offer relatively high
+      #    responsiveness to changes in the input signal, reflecting recent price movements
+      #    quickly. This responsiveness can be advantageous for certain trading strategies
+      #    that rely on timely identification of market events or short-term trends.
+      #
+      # Overall, applying a single-pole high-pass filter to stock price action data can
+      # help in removing low-frequency trends and focusing on short-term variations and
+      # rapid movements. However, it's essential to carefully select the cutoff frequency
+      # to balance noise attenuation with signal preservation and to consider the potential
+      # trade-offs between simplicity and filtering effectiveness.
+      def universal_one_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)
+
+        alpha = period_to_alpha(period, k: K[:single_pole])
+        b0 = (1 - alpha / 2)
+        b1 = -(1 - alpha / 2)
+        b2 = 0
+        a1 = -(1 - alpha)
+        a2 = 0
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+
+      # A two-pole high-pass filter, also known as a second-order high-pass
+      # filter, attenuates low-frequency components of a signal while allowing
+      # higher-frequency components to pass through. In the context of
+      # processing stock price action data, applying a two-pole high-pass
+      # filter has several potential effects:
+      #
+      # 1. Removal of Low-Frequency Trends: High-pass filtering can remove
+      #    or attenuate long-term trends or slow-moving components of the
+      #    price action data. This can be useful for focusing on shorter-term
+      #    fluctuations or identifying short-term trading opportunities.
+      # 2. Noise Attenuation: By suppressing low-frequency components, a
+      #    high-pass filter can help in reducing the impact of slow-moving
+      #    noise or irrelevant signals in the data. This can improve the
+      #    clarity and interpretability of the price action data.
+      # 3. Noise Amplification: High-pass filters can amplify high-frequency
+      #    noise present in the data, particularly if the cutoff frequency is
+      #    set too low. This noise amplification can make it challenging to
+      #    analyze the data accurately, especially if the noise overwhelms
+      #    the signal of interest.
+      # 4. Emphasis on Short-Term Variations: By removing low-frequency
+      #    components, a high-pass filter highlights short-term variations
+      #    and rapid movements in the price action data. This can be beneficial
+      #    for traders or analysts who are primarily interested in short-term
+      #    price dynamics.
+      # 5. Enhanced Responsiveness: Compared to low-pass filters, high-pass
+      #    filters typically offer greater responsiveness to changes in the
+      #    input signal. This means that high-pass filtered data can reflect
+      #    recent price movements more quickly, which may be advantageous for
+      #    certain trading strategies.
+      # 6. Identification of Market Events: High-pass filtering can help in
+      #    identifying specific market events or anomalies that occur on
+      #    shorter time scales, such as intraday price spikes or volatility
+      #    clusters.
+      #
+      # Overall, applying a two-pole high-pass filter to stock price action
+      # data can help in focusing on short-term variations and removing
+      # long-term trends or slow-moving components. However, it's essential
+      # to carefully select the cutoff frequency to balance noise attenuation
+      # with signal preservation, as excessive noise amplification can degrade
+      # the quality of the analysis. Additionally, high-pass filtering may
+      # 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)
+
+        alpha = period_to_alpha(period, k: K[:two_pole_high_pass])
+        b0 = (1 - alpha / 2)**2
+        b1 = -2 * (1 - alpha / 2)**2
+        b2 = (1 - alpha / 2)**2
+        a1 = -2 * (1 - alpha)
+        a2 = (1 - alpha)**2
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+
+      # Band-pass filters are both detrenders and smoothers because they
+      # attenuate all but the desired frequency components.
+      # NOTE: Ehlers' book contains a typo in the formula for the band-pass
+      # filter.  I am not sure what the correct formulation is, so
+      # this is a best guess for how, left for further investigation.
+      def universal_band_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)
+
+        lambda = deg2rad(360.0 / period)
+        gamma = Math.cos(lambda)
+        sigma = 1 / gamma - Math.sqrt(1 / gamma**2 - 1)
+
+        b0 = (1 - sigma) * 0.5
+        b1 = 0
+        b2 = -(1 - sigma) * 0.5
+        a1 = -lambda * (1 + sigma)
+        a2 = sigma
+
+        universal_filter(source, previous:, b0:, b1:, b2:, a1:, a2:)
+      end
+    end
+  end
+end

data/lib/quant/series.rb

@@ -114,7 +114,7 @@ module Quant
 
     def to_h
       { "symbol" => symbol,
-        "interval" => interval,
+        "interval" => interval.to_s,
         "ticks" => ticks.map(&:to_h) }
     end
 

data/lib/quant/ticks/ohlc.rb

@@ -82,9 +82,10 @@ module Quant
       # A value of 0.0 means no change.
       # @return [Float]
       def daily_price_change
-        ((open_price / close_price) - 1.0)
-      rescue ZeroDivisionError
-        0.0
+        return open_price.zero? ? 0.0 : -1.0 if close_price.zero?
+        return 0.0 if open_price == close_price
+
+        (open_price / close_price) - 1.0
       end
 
       # Calculates the absolute change from the open_price to the close_price, divided by the average of the
@@ -93,7 +94,7 @@ module Quant
       # This method is useful for comparing the volatility of different assets.
       # @return [Float]
       def daily_price_change_ratio
-        @daily_price_change_ratio ||= ((open_price - close_price) / oc2).abs
+        (open_price - close_price).abs / oc2
       end
 
       # Set the #green? property to true when the close_price is greater than or equal to the open_price.

data/lib/quant/time_methods.rb

@@ -41,6 +41,10 @@ module Quant
       case value
       when Time
         value.utc
+      when DateTime
+        Time.new(value.year, value.month, value.day, value.hour, value.minute, value.second).utc
+      when Date
+        Time.utc(value.year, value.month, value.day, 0, 0, 0)
       when Integer
         Time.at(value).utc
       when String

data/lib/quant/time_period.rb

@@ -36,7 +36,7 @@ module Quant
     def validate_bounds!
       return if lower_bound? || upper_bound?
 
-      raise "TimePeriod cannot be unbounded at start_at and end_at"
+      raise "TimePeriod cannot be unbound at start_at and end_at"
     end
 
     def cover?(value)
@@ -48,11 +48,19 @@ module Quant
     end
 
     def lower_bound?
-      !!@start_at
+      !lower_unbound?
+    end
+
+    def lower_unbound?
+      @start_at.nil?
+    end
+
+    def upper_unbound?
+      @end_at.nil?
     end
 
     def upper_bound?
-      !!@end_at
+      !upper_unbound?
     end
 
     def end_at
@@ -66,17 +74,8 @@ module Quant
     def ==(other)
       return false unless other.is_a?(TimePeriod)
 
-      if lower_bound?
-        other.lower_bound? && start_at == other.start_at
-      elsif upper_bound?
-        oher.upper_bound? && end_at == other.end_at
-      else
-        [start_at, end_at] == [other.start_at, other.end_at]
-      end
-    end
-
-    def eql?(other)
-      self == other
+      [lower_bound?, upper_bound?, start_at, end_at] ==
+        [other.lower_bound?, other.upper_bound?, other.start_at, other.end_at]
     end
 
     def to_h

data/lib/quant/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-28 00:00:00.000000000 Z
+date: 2024-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -49,6 +49,7 @@ files:
 - lib/quant/attributes.rb
 - lib/quant/config.rb
 - lib/quant/errors.rb
+- lib/quant/experimental.rb
 - lib/quant/indicators.rb
 - lib/quant/indicators/indicator.rb
 - lib/quant/indicators/indicator_point.rb
@@ -63,12 +64,13 @@ files:
 - lib/quant/mixins/filters.rb
 - lib/quant/mixins/fisher_transform.rb
 - lib/quant/mixins/functions.rb
-- lib/quant/mixins/high_pass_filter.rb
+- lib/quant/mixins/high_pass_filters.rb
 - lib/quant/mixins/hilbert_transform.rb
 - lib/quant/mixins/moving_averages.rb
 - lib/quant/mixins/simple_moving_average.rb
 - lib/quant/mixins/stochastic.rb
 - lib/quant/mixins/super_smoother.rb
+- lib/quant/mixins/universal_filters.rb
 - lib/quant/mixins/weighted_moving_average.rb
 - lib/quant/refinements/array.rb
 - lib/quant/series.rb