quantitative 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72d65b65fdcbb81650fcce3233f3fbde9c99c4b9b9ace1ce3bbc3b8e565152f9
-  data.tar.gz: f687ab3c32e88ffc579a9f92ff428846f91e60ff166d3b4379963deb15a88425
+  metadata.gz: 8c2f8345b245cd469b234752f2fb757a1006b6a04322412acbb3fc10bd759827
+  data.tar.gz: fa5388e69c9f82fe686424dcfd81d8795ea6814a4b2b98b0edb6a52598ffbdaf
 SHA512:
-  metadata.gz: 594d57a819ce8d561c064f685353d27ef4dfd1cb2e76e5cf07758bcedb1c501d2bc06859aff89cf6f4bc744e327ede1290e31b4d4ffb1daed99d614735eb0a76
-  data.tar.gz: 5fbfb29d1501a3562788abf83ef4fcb78bcb17fcfc030e7543b42f3c29c2a7a5c3c8fba187494d4655691e117e383af59bca428764f49fd7e41fcef911ef6d40
+  metadata.gz: bb3c3cc8db589f5051d9dcd921fc1c01292897c440cfdb72c45df568051213ddd3fad5aa27e40652aff452619eefa835dcc4675120d050c9a46bbf34e83be3cc
+  data.tar.gz: cfcc8acf5989103a9a59b84965b3d1d3eb1f3288737afa3636f684ea5f378e10d82f4bda5e487f9a1ddcb867abd0fb82cef4048219acac6ee98bcfd412124db5

data/Gemfile.lock

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

data/lib/quant/indicators/indicator.rb

@@ -4,10 +4,8 @@ module Quant
   class Indicators
     class Indicator
       include Enumerable
-
-      # # include Mixins::TrendMethods
-      # include Mixins::Trig
-      # include Mixins::WeightedAverage
+      include Mixins::Functions
+      include Mixins::MovingAverages
       # include Mixins::HilbertTransform
       # include Mixins::SuperSmoother
       # include Mixins::Stochastic

data/lib/quant/mixins/exponential_moving_average.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module ExponentialMovingAverage
+      # Computes the Exponential Moving Average (EMA) of the given period.
+      #
+      # The EMA computation is optimized to compute using just the last two
+      # indicator data points and is expected to be called in each indicator's
+      # `#compute` method for each iteration on the series.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @param previous [Symbol] the previous EMA value.
+      # @param period [Integer] the number of elements to compute the EMA over.
+      # @return [Float] the exponential moving average of the period.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   def compute
+      #     p0.ema = exponential_moving_average(:close_price, period: 3)
+      #   end
+      #
+      #   def compute
+      #     p0.ema = exponential_moving_average(:close_price, previous: :ema, period: 3)
+      #   end
+      def exponential_moving_average(source, period:, previous: :ema)
+        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)
+        p0.send(source) * alpha + p1.send(previous) * (1.0 - alpha)
+      end
+      alias ema exponential_moving_average
+    end
+  end
+end

data/lib/quant/mixins/filters.rb

@@ -1,66 +1,53 @@
 # frozen_string_literal: true
 
-require_relative "trig"
+require_relative "functions"
 
 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.
+    # 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.
+    # 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+σ)  σ
     #
-    # 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::Trig
-
-      # α = Cos(K*360/Period)+Sin(K*360/Period)−1 / Cos(K*360/Period)
-      # k = 1.0 for single-pole filters
-      # 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)
-        cos = Math.cos(radians)
-        sin = Math.sin(radians)
-        (cos + sin - 1) / cos
-      end
-
-      # 3 bars = 0.5
-      # 4 bars = 0.4
-      # 5 bars = 0.333
-      # 6 bars = 0.285
-      # 10 bars = 0.182
-      # 20 bars = 0.0952
-      # 40 bars = 0.0488
-      # 50 bars = 0.0392
-      def bars_to_alpha(bars)
-        2.0 / (bars + 1)
-      end
+      include Mixins::Functions
 
       def ema(source, prev_source, period)
         alpha = bars_to_alpha(period)

data/lib/quant/mixins/{trig.rb → functions.rb}

@@ -2,7 +2,30 @@
 
 module Quant
   module Mixins
-    module Trig
+    module Functions
+      # α = Cos(K*360/Period)+Sin(K*360/Period)−1 / Cos(K*360/Period)
+      # k = 1.0 for single-pole filters
+      # 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)
+        cos = Math.cos(radians)
+        sin = Math.sin(radians)
+        (cos + sin - 1) / cos
+      end
+
+      # 3 bars = 0.5
+      # 4 bars = 0.4
+      # 5 bars = 0.333
+      # 6 bars = 0.285
+      # 10 bars = 0.182
+      # 20 bars = 0.0952
+      # 40 bars = 0.0488
+      # 50 bars = 0.0392
+      def bars_to_alpha(bars)
+        2.0 / (bars + 1)
+      end
+
       def deg2rad(degrees)
         degrees * Math::PI / 180.0
       end

data/lib/quant/mixins/moving_averages.rb

@@ -1,86 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "weighted_moving_average"
+require_relative "simple_moving_average"
+require_relative "exponential_moving_average"
 module Quant
   module Mixins
     module MovingAverages
-      using Quant
-
-      # Computes the Weighted Moving Average (WMA) of the series, using the four most recent data points.
-      #
-      # @param source [Symbol] the source of the data points to be used in the calculation.
-      # @return [Float] the weighted average of the series.
-      # @raise [ArgumentError] if the source is not a Symbol.
-      # @example
-      #   p0.wma = weighted_average(:close_price)
-      def weighted_moving_average(source)
-        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
-
-        [4.0 * p0.send(source),
-         3.0 * p1.send(source),
-         2.0 * p2.send(source),
-               p3.send(source)].sum / 10.0
-      end
-      alias wma weighted_moving_average
-
-      # Computes the Weighted Moving Average (WMA) of the series, using the seven most recent data points.
-      #
-      # @param source [Symbol] the source of the data points to be used in the calculation.
-      # @return [Float] the weighted average of the series.
-      # @raise [ArgumentError] if the source is not a Symbol.
-      # @example
-      #   p0.wma = weighted_average(:close_price)
-      def extended_weighted_moving_average(source)
-        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
-
-        [7.0 * p0.send(source),
-         6.0 * p1.send(source),
-         5.0 * p2.send(source),
-         4.0 * p3.send(source),
-         3.0 * p(4).send(source),
-         2.0 * p(5).send(source),
-               p(6).send(source)].sum / 28.0
-      end
-      alias ewma extended_weighted_moving_average
-
-      # Computes the Simple Moving Average (SMA) of the given period.
-      #
-      # @param source [Symbol] the source of the data points to be used in the calculation.
-      # @param period [Integer] the number of elements to compute the SMA over.
-      # @return [Float] the simple moving average of the period.
-      def simple_moving_average(source, period:)
-        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
-
-        values.last(period).map { |value| value.send(source) }.mean
-      end
-      alias sma simple_moving_average
-
-      # Computes the Exponential Moving Average (EMA) of the given period.
-      #
-      # The EMA computation is optimized to compute using just the last two
-      # indicator data points and is expected to be called in each indicator's
-      # `#compute` method for each iteration on the series.
-      #
-      # @param source [Symbol] the source of the data points to be used in the calculation.
-      # @param previous [Symbol] the previous EMA value.
-      # @param period [Integer] the number of elements to compute the EMA over.
-      # @return [Float] the exponential moving average of the period.
-      # @raise [ArgumentError] if the source is not a Symbol.
-      # @example
-      #   def compute
-      #     p0.ema = exponential_moving_average(:close_price, period: 3)
-      #   end
-      #
-      #   def compute
-      #     p0.ema = exponential_moving_average(:close_price, previous: :ema, period: 3)
-      #   end
-      def exponential_moving_average(source, previous: :ema, 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 = 2.0 / (period + 1)
-        p0.send(source) * alpha + p1.send(previous) * (1.0 - alpha)
-      end
-      alias ema exponential_moving_average
+      include WeightedMovingAverage
+      include SimpleMovingAverage
+      include ExponentialMovingAverage
     end
   end
 end

data/lib/quant/mixins/simple_moving_average.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module SimpleMovingAverage
+      using Quant
+
+      # Computes the Simple Moving Average (SMA) of the given period.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @param period [Integer] the number of elements to compute the SMA over.
+      # @return [Float] the simple moving average of the period.
+      def simple_moving_average(source, period:)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        values.last(period).map { |value| value.send(source) }.mean
+      end
+      alias sma simple_moving_average
+    end
+  end
+end

data/lib/quant/mixins/super_smoother.rb

@@ -3,73 +3,29 @@
 module Quant
   module Mixins
     module SuperSmoother
-      def super_smoother(source, prev_source, period)
-        v0 = (source.is_a?(Symbol) ? p0.send(source) : source).to_d
-        return v0.to_f if points.size < 4
+      def two_pole_super_smooth(source, period:, previous: :ss)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
-        k = Math.exp(-Math.sqrt(2) * Math::PI / period)
-        coef3 = -k**2
-        coef2 = 2.0 * k * Math.cos(Math.sqrt(2) * (Math::PI / 2) / period)
-        coef1 = 1.0 - coef2 - coef3
-
-        v1 = p1.send(prev_source).to_d
-        v2 = p2.send(prev_source).to_d
-        p3.send(prev_source).to_d
-        ((coef1 * (v0 + v1)) / 2.0 + (coef2 * v1) + (coef3 * v2)).to_f
-      end
-
-      def two_pole_super_smooth(source, prev_source, ssperiod)
-        return p1.send(source) if [p1 == p3]
-
-        radians = Math::PI * Math.sqrt(2) / ssperiod
+        radians = Math::PI * Math.sqrt(2) / period
         a1 = Math.exp(-radians)
 
-        coef2 = 2.0 * a1 * Math.cos(radians)
+        coef2 = 2.0r * a1 * Math.cos(radians)
         coef3 = -a1 * a1
         coef1 = 1.0 - coef2 - coef3
 
-        v0 = (p1.send(source) + p2.send(source)) / 2.0
-        v1 = p2.send(prev_source)
-        v2 = p3.send(prev_source)
-        (coef1 * v0) + (coef2 * v1) + (coef3 * v2)
+        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
       end
+      alias super_smoother two_pole_super_smooth
+      alias ss2p two_pole_super_smooth
 
-      def three_pole_super_smooth(source, prev_source, ssperiod)
-        a1 = Math.exp(-Math::PI / ssperiod)
-        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / ssperiod)
-        c1 = a1**2
+      def three_pole_super_smooth(source, period:, previous: :ss)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
-        coef2 = b1 + c1
-        coef3 = -(c1 + b1 * c1)
-        coef4 = c1**2
-        coef1 = 1 - coef2 - coef3 - coef4
-
-        p0 = prev(0)
-        p1 = prev(1)
-        p2 = prev(2)
-        p3 = prev(3)
-
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
-        return v0 if [p0, p1, p2].include?(p3)
-
-        v1 = p1.send(prev_source)
-        v2 = p2.send(prev_source)
-        v3 = p3.send(prev_source)
-        (coef1 * v0) + (coef2 * v1) + (coef3 * v2) + (coef4 * v3)
-      end
-
-      # super smoother 3 pole
-      def ss3p(source, prev_source, ssperiod)
-        p0 = points[-1]
-        p1 = points[-2] || p0
-        p2 = points[-3] || p1
-        p3 = points[-4] || p2
-
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
-        return v0 if p0 == p3
-
-        a1 = Math.exp(-Math::PI / ssperiod)
-        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / ssperiod)
+        a1 = Math.exp(-Math::PI / period)
+        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / period)
         c1 = a1**2
 
         coef2 = b1 + c1
@@ -77,56 +33,14 @@ module Quant
         coef4 = c1**2
         coef1 = 1 - coef2 - coef3 - coef4
 
-        v1 = p1.send(prev_source)
-        v2 = p2.send(prev_source)
-        v3 = p3.send(prev_source)
+        v0 = p0.send(source)
+        v1 = p1.send(previous)
+        v2 = p2.send(previous)
+        v3 = p3.send(previous)
+
         (coef1 * v0) + (coef2 * v1) + (coef3 * v2) + (coef4 * v3)
       end
-
-      #   attr_reader :hpfs, :value1s, :hpf_psns
-
-      #   def hpf
-      #     @hpfs[-1]
-      #   end
-
-      #   def hpf_psn
-      #     @hpf_psns[-1]
-      #   end
-
-      #   def prev offset, source
-      #     idx = offset + 1
-      #     source[[-idx, -source.size].max]
-      #   end
-
-      #   def weighted_average source
-      #     [ 4.0 * prev(0, source),
-      #       3.0 * prev(1, source),
-      #       2.0 * prev(2, source),
-      #             prev(3, source),
-      #     ].sum / 10.0
-      #   end
-
-      #   def compute_hpf
-      #     @hpfs ||= []
-      #     @value1s ||= []
-      #     @hpf_psns ||= []
-      #     max_cycle = period * 10
-
-      #     r = (360.0 / max_cycle) * (Math::PI / 180)
-      #     alpha = (1 - Math::sin(r)) / Math::cos(r)
-      #     hpf = @hpfs.empty? ? 0.0 : (0.5 * (1.0 + alpha) * (current_value - prev_value(1))) + (alpha * (@hpfs[-1]))
-
-      #     @hpfs << hpf
-      #     @hpfs.shift if @hpfs.size > max_cycle
-
-      #     hh = @hpfs.max
-      #     ll = @hpfs.min
-      #     @value1s << value1 = (hh == ll ? 0.0 : 100 * (hpf - ll) / (hh - ll))
-      #     @value1s.shift if @value1s.size > max_cycle
-
-      #     @hpf_psns << weighted_average(@value1s)
-      #     @hpf_psns.shift if @hpf_psns.size > max_cycle
-      #   end
+      alias ss3p three_pole_super_smooth
     end
   end
 end

data/lib/quant/mixins/weighted_moving_average.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module WeightedMovingAverage
+      using Quant
+      # Computes the Weighted Moving Average (WMA) of the series, using the four most recent data points.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @return [Float] the weighted average of the series.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   p0.wma = weighted_average(:close_price)
+      def weighted_moving_average(source)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        [4.0 * p0.send(source),
+         3.0 * p1.send(source),
+         2.0 * p2.send(source),
+               p3.send(source)].sum / 10.0
+      end
+      alias wma weighted_moving_average
+
+      # Computes the Weighted Moving Average (WMA) of the series, using the seven most recent data points.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @return [Float] the weighted average of the series.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   p0.wma = weighted_average(:close_price)
+      def extended_weighted_moving_average(source)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        [7.0 * p0.send(source),
+         6.0 * p1.send(source),
+         5.0 * p2.send(source),
+         4.0 * p3.send(source),
+         3.0 * p(4).send(source),
+         2.0 * p(5).send(source),
+               p(6).send(source)].sum / 28.0
+      end
+      alias ewma extended_weighted_moving_average
+    end
+  end
+end

data/lib/quant/ticks/ohlc.rb

@@ -4,11 +4,15 @@ require_relative "tick"
 
 module Quant
   module Ticks
-    # An {Quant::Ticks::OHLC} is a bar or candle for a point in time that has an open, high, low, and close price.
-    # It is the most common form of a {Quant::Ticks::Tick} and is usually used to representa time period such as a
-    # minute, hour, day, week, or month.  The {Quant::Ticks::OHLC} is used to represent the price action of an asset
-    # The interval of the {Quant::Ticks::OHLC} is the time period that the {Quant::Ticks::OHLC} represents,
-    # such has hourly, daily, weekly, etc.
+    # A {Quant::Ticks::OHLC} is a bar or candle for a point in time that
+    # has an open, high, low, and close price. It is the most common form
+    # of a {Quant::Ticks::Tick} and is usually used to representa time
+    # period such as a minute, hour, day, week, or month.
+    #
+    # The {Quant::Ticks::OHLC} is used to represent the price action of
+    # an asset The interval of the {Quant::Ticks::OHLC} is the time period
+    # that the {Quant::Ticks::OHLC} represents, such has hourly, daily,
+    # weekly, etc.
     class OHLC < Tick
       include TimeMethods
 

data/lib/quant/ticks/tick.rb

@@ -2,22 +2,29 @@
 
 module Quant
   module Ticks
-    # {Quant::Ticks::Tick} is the abstract ancestor for all Ticks and holds the logic for interacting with series and indicators.
-    # The public interface is devoid of properties around price, volume, and timestamp, etc.  Descendant classes
-    # are responsible for defining the properties and how they are represented.
-    #
-    # The {Quant::Ticks::Tick} class is designed to be immutable and is intended to be used as a value object.  This means that
-    # once a {Quant::Ticks::Tick} is created, it cannot be changed.  This is important for the integrity of the series and
-    # indicators that depend on the ticks within the series.
-    #
-    # When a tick is added to a series, it is locked into the series and ownership cannot be changed.  This is important
-    # for the integrity of the series and indicators that depend on the ticks within the series.  This is a key design
-    # to being able to being able to not only compute indicators on the ticks just once, but also avoid recomputing
-    # indicators when series are limited/sliced/filtered into subsets of the original series.
-    #
+    # {Quant::Ticks::Tick} is the abstract ancestor for all Ticks and holds
+    # the logic for interacting with series and indicators. The public
+    # interface is devoid of properties around price, volume, and timestamp, etc.
+    # Descendant classes are responsible for defining the properties and
+    # how they are represented.
+
+    # The {Quant::Ticks::Tick} class is designed to be immutable and is
+    # intended to be used as a value object.  This means that once a
+    # {Quant::Ticks::Tick} is created, it cannot be changed.  This is important
+    # for the integrity of the series and indicators that depend on the
+    # ticks within the series.
+
+    # When a tick is added to a series, it is locked into the series and
+    # ownership cannot be changed.  This is important for the integrity
+    # of the series and indicators that depend on the ticks within the series.
+    # This is a key design to being able to being able to not only compute
+    # indicators on the ticks just once, but also avoid recomputing indicators
+    # when series are limited/sliced/filtered into subsets of the original series.
+
     # Ticks can be serialized to and from Ruby Hash, JSON strings, and CSV strings.
     class Tick
-      # Returns a {Quant::Ticks::Tick} from a Ruby +Hash+.  The default serializer is used to generate the {Quant::Ticks::Tick}.
+      # Returns a {Quant::Ticks::Tick} from a Ruby +Hash+.  The default
+      # serializer is used to generate the {Quant::Ticks::Tick}.
       # @param hash [Hash]
       # @param serializer_class [Class] The serializer class to use for the conversion.
       # @return [Quant::Ticks::Tick]
@@ -30,7 +37,8 @@ module Quant
         serializer_class.from(hash, tick_class: self)
       end
 
-      # Returns a {Quant::Ticks::Tick} from a JSON string.  The default serializer is used to generate the {Quant::Ticks::Tick}.
+      # Returns a {Quant::Ticks::Tick} from a JSON string.  The default
+      # serializer is used to generate the {Quant::Ticks::Tick}.
       # @param json [String]
       # @param serializer_class [Class] The serializer class to use for the conversion.
       # @return [Quant::Ticks::Tick]
@@ -80,7 +88,8 @@ module Quant
         self
       end
 
-      # Returns a Ruby hash for the Tick.  The default serializer is used to generate the hash.
+      # Returns a Ruby hash for the Tick.  The default serializer is used
+      # to generate the hash.
       #
       # @param serializer_class [Class] the serializer class to use for the conversion.
       # @example
@@ -90,7 +99,8 @@ module Quant
         serializer_class.to_h(self)
       end
 
-      # Returns a JSON string for the Tick.  The default serializer is used to generate the JSON string.
+      # Returns a JSON string for the Tick.  The default serializer is used
+      # to generate the JSON string.
       #
       # @param serializer_class [Class] the serializer class to use for the conversion.
       # @example
@@ -100,8 +110,9 @@ module Quant
         serializer_class.to_json(self)
       end
 
-      # Returns a CSV row as a String for the Tick.  The default serializer is used to generate the CSV string.
-      # If headers is true, two lines returned separated by newline.
+      # Returns a CSV row as a String for the Tick.  The default serializer
+      # is used to generate the CSV string.  If headers is true, two lines
+      # returned separated by newline.
       # The first line is the header row and the second line is the data row.
       #
       # @param serializer_class [Class] the serializer class to use for the conversion.

data/lib/quant/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-25 00:00:00.000000000 Z
+date: 2024-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -58,14 +58,17 @@ files:
 - lib/quant/indicators_sources.rb
 - lib/quant/interval.rb
 - lib/quant/mixins/direction.rb
+- lib/quant/mixins/exponential_moving_average.rb
 - 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/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/trig.rb
+- lib/quant/mixins/weighted_moving_average.rb
 - lib/quant/refinements/array.rb
 - lib/quant/series.rb
 - lib/quant/settings.rb