quantitative 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9fa0c537499409fa9faa3fbca76beca44d37205c04c8de1c01b3e681985c2dc
-  data.tar.gz: 3916820207b47d2d19b79332e41329c35080ce1456c4a2ed751863ea220b5289
+  metadata.gz: 8c2f8345b245cd469b234752f2fb757a1006b6a04322412acbb3fc10bd759827
+  data.tar.gz: fa5388e69c9f82fe686424dcfd81d8795ea6814a4b2b98b0edb6a52598ffbdaf
 SHA512:
-  metadata.gz: e3bead0b7fc23208c62dd18bb8f701b684db20780ae793fab973ab07cea0740897026a66755a07b9857228e815bfc3679801171f2b5875f510a7c98781fd30cb
-  data.tar.gz: 8b07dbcbe1a86c507a31df950aef293ae018913964848a9298310fe71a7929924a5a7ced417cf5ef86e9282feb58bc9d16531bf6b77e0fa23cea28de7a761740
+  metadata.gz: bb3c3cc8db589f5051d9dcd921fc1c01292897c440cfdb72c45df568051213ddd3fad5aa27e40652aff452619eefa835dcc4675120d050c9a46bbf34e83be3cc
+  data.tar.gz: cfcc8acf5989103a9a59b84965b3d1d3eb1f3288737afa3636f684ea5f378e10d82f4bda5e487f9a1ddcb867abd0fb82cef4048219acac6ee98bcfd412124db5

data/.rubocop.yml

@@ -3,6 +3,8 @@ inherit_gem:
 
 AllCops:
   TargetRubyVersion: 3.0
+  Exclude:
+    - 'spec/performance/*.rb'
 
 Style/AccessorGrouping:
   Enabled: false

data/Gemfile.lock

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

data/lib/quant/attributes.rb

@@ -1,10 +1,60 @@
 # frozen_string_literal: true
 
 module Quant
+  # {Quant::Attributes} is similar to an +attr_accessor+ definition.  It provides a simple DSL
+  # for defining attributes or properies on an {Quant::Indicators::IndicatorPoint} class.
+  #
+  # {Quant::Attributes} tracks all defined attributes from child to parent classes,
+  # allowing child classes to inherit their parent's attributes as well as redefine them.
+  #
+  # The exception on redefining is that a serialized key cannot be redefined.  Experience
+  # has proven that this leads to serialization surprises where what was written to a specific
+  # key is not what was expected!
+  #
+  # NOTE: The above design constraint could be improved with a force or overwrite option.
+  #
+  # If :default is an immediate value (Integer, Float, Boolean, etc.), it will be used as the
+  # initial value for the attribute.  If :default is a Symbol, it will send a message on
+  # current instance of the class get the default value.
+  #
+  # @example
+  #   class FooPoint < IndicatorPoint
+  #     # will not serialize to a key
+  #     attribute :bar
+  #     # serializes to "bzz" key
+  #     attribute :baz, key: "bzz"
+  #     # calls the random method on the instance for the default value
+  #     attribute :foobar, default: :random
+  #     # delegated to the tick's high_price method
+  #     attribute :high, default: :high_price
+  #     # calls the lambda bound to instance for default
+  #     attribute :low, default: -> { high_price - 5 }
+  #
+  #     def random
+  #       rand(100)
+  #     end
+  #   end
+  #
+  #   class BarPoint < FooPoint
+  #     attribute :bar, key: "brr"                 # redefines and sets the key for bar
+  #     attribute :qux, key: "qxx", default: 5.0   # serializes to "qxx" and defaults to 5.0
+  #   end
+  #
+  #   FooPoint.attributes
+  #   # => { bar: { key: nil, default: nil },
+  #          baz: { key: "bzz", default: nil } }
+  #
+  #   BarPoint.attributes
+  #   # => { bar: { key: "brr", default: nil },
+  #   #      baz: { key: "bzz", default: nil },
+  #   #      qux: { key: "qxx", default: nil } }
+  #
+  #   BarPoint.new.bar # => nil
+  #   BarPoint.new.qux # => 5.0
+  #   BarPoint.new.bar = 2.0 => 2.0
   module Attributes
-    # Tracks all defined attributes, allowing child classes to inherit their parent's attributes.
-    # The registry key is the class registering an attrbritute and is itself a hash of the attribute name
-    # and the attribute's key and default value.
+    # The +registry+ key is the class registering an attrbritute and is itself
+    # a hash of the attribute name and the attribute's key and default value.
     # Internal use only.
     #
     # @example
@@ -47,9 +97,18 @@ module Quant
     end
 
     module InstanceMethods
-      def initialize(...)
-        initialize_attributes
-        super(...)
+      # 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)
       end
 
       # Iterates over all defined attributes in a child => parent hierarchy,
@@ -65,17 +124,42 @@ module Quant
         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 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])
+
+        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
+      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
+      def initialize_attributes(tick:)
         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, entry[:default])
+          instance_variable_set(ivar_name, default_value_for(entry, tick))
           define_singleton_method(name) { instance_variable_get(ivar_name) }
           define_singleton_method("#{name}=") { |value| instance_variable_set(ivar_name, value) }
         end

data/lib/quant/indicators/indicator.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 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
@@ -27,6 +27,10 @@ module Quant
         @points.keys
       end
 
+      def [](index)
+        values[index]
+      end
+
       def values
         @points.values
       end
@@ -59,7 +63,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} symbol=#{series.symbol} source=#{source} #{points.size} ticks>"
+        "#<#{self.class.name} symbol=#{series.symbol} source=#{source} #{ticks.size} ticks>"
       end
 
       def compute
@@ -168,4 +172,4 @@ module Quant
       # end
     end
   end
-end
+end

data/lib/quant/indicators/indicator_point.rb

@@ -5,7 +5,7 @@ module Quant
     class IndicatorPoint
       include Quant::Attributes
 
-      attribute :tick
+      attr_reader :tick
       attribute :source, key: "src"
       attribute :input, key: "in"
 

data/lib/quant/indicators/ma.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
     class MaPoint < IndicatorPoint

data/lib/quant/indicators/ping.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
+    # A simple point used primarily to test the indicator system in unit tests.
+    # It has a simple computation that just sets the pong value to the input value
+    # and increments the compute_count by 1 each time compute is called.
+    # Sometimes you just gotta play ping pong to win.
     class PingPoint < IndicatorPoint
       attribute :pong
       attribute :compute_count, default: 0

data/lib/quant/indicators_proxy.rb

@@ -1,6 +1,17 @@
 # frozen_string_literal: true
 
 module Quant
+  # The {Quant::IndicatorsProxy} class is responsible for lazily loading indicators
+  # so that not all indicators are always engaged and computing their values.
+  # If the indicator is never accessed, it's never computed, saving valuable
+  # processing CPU cycles.
+  #
+  # Indicators are generally built around the concept of a source input value and
+  # that source is designated by the source parameter when instantiating the
+  # {Quant::IndicatorsProxy} class.
+  #
+  # By design, the {Quant::Indicator} class holds the {Quant::Ticks::Tick} instance
+  # alongside the indicator's computed values for that tick.
   class IndicatorsProxy
     attr_reader :series, :source, :indicators
 
@@ -10,14 +21,41 @@ module Quant
       @indicators = {}
     end
 
+    # Instantiates the indicator class and stores it in the indicators hash.  Once
+    # prepared, the indicator becomes active and all ticks pushed into the series
+    # are sent to the indicator for processing.
     def indicator(indicator_class)
       indicators[indicator_class] ||= indicator_class.new(series: series, source: source)
     end
 
+    # Adds the tick to all active indicators, triggering them to compute
+    # new values against the latest tick.
+    #
+    # NOTE:  Dominant cycle indicators must be computed first as many
+    # indicators are adaptive and require the dominant cycle period.
+    # The IndicatorsProxy class is not responsible for enforcing
+    # this order of events.
     def <<(tick)
       indicators.each_value { |indicator| indicator << tick }
     end
 
+    # Attaches a given Indicator class and defines the method for
+    # accessing it using the given name.  Indicators take care of
+    # computing their values when first attached to a populated
+    # series.
+    #
+    # The indicators shipped with the library are all wired into the framework, thus
+    # this method should be used for custom indicators not shipped with the library.
+    #
+    # @param name [Symbol] The name of the method to define for accessing the indicator.
+    # @param indicator_class [Class] The class of the indicator to attach.
+    # @example
+    #   series.indicators.oc2.attach(name: :foo, indicator_class: Indicators::Foo)
+    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/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

@@ -0,0 +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
+      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,74 +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]
-
-        debugger if points.size > 4
-        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
@@ -78,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/refinements/array.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   module Refinements
     # Refinements for the standard Ruby {Quant::Array} class.
@@ -32,7 +34,6 @@ module Quant
     #   The refined behavior generally only exists within the library's scope, but if you call `using Quant` in your
     #   own code, you may encounter the changed behavior unexpectedly.
     module Array
-
       # Overrides the standard +<<+ method to track the +maximum+ and +minimum+ values
       # while also respecting the +max_size+ setting.
       def <<(value)
@@ -109,7 +110,7 @@ module Quant
         subset = last(n)
         return 0.0 if subset.empty?
 
-        sum = subset.sum / subset.size.to_f
+        subset.sum / subset.size.to_f
       end
 
       # Computes the Exponential Moving Average (EMA) of the array.  When +n+ is specified,
@@ -175,7 +176,7 @@ module Quant
       # @param n [Integer] the number of elements to compute the Standard Deviation over.
       # @return [Float]
       def stddev(reference_value, n: size)
-        variance(reference_value, n: n) ** 0.5
+        variance(reference_value, n: n)**0.5
       end
 
       def variance(reference_value, n: size)

data/lib/quant/settings.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   module Settings
     MAX_PERIOD = 48

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
 
@@ -89,7 +93,7 @@ module Quant
       # This method is useful for comparing the volatility of different assets.
       # @return [Float]
       def daily_price_change_ratio
-        @price_change ||= ((open_price - close_price) / oc2).abs
+        @daily_price_change_ratio ||= ((open_price - close_price) / oc2).abs
       end
 
       # Set the #green? property to true when the close_price is greater than or equal to the open_price.

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.5"
+  VERSION = "0.1.7"
 end

data/lib/quantitative.rb

@@ -14,4 +14,4 @@ Dir.glob(File.join(quant_folder, "*.rb")).each { |fn| require fn }
 # require sub-folders and their sub-folders
 %w(refinements mixins settings ticks indicators).each do |sub_folder|
   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  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_average.rb
+- lib/quant/mixins/weighted_moving_average.rb
 - lib/quant/refinements/array.rb
 - lib/quant/series.rb
 - lib/quant/settings.rb

data/lib/quant/mixins/weighted_average.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Quant
-  module Mixins
-    module WeightedAverage
-      def weighted_average(source)
-        value = source.is_a?(Symbol) ? p0.send(source) : source
-        [4.0 * value,
-         3.0 * p1.send(source),
-         2.0 * p2.send(source),
-         p3.send(source),].sum / 10.0
-      end
-
-      def extended_weighted_average(source)
-        value = source.is_a?(Symbol) ? p0.send(source) : source
-        [7.0 * value,
-         6.0 * p1.send(source),
-         5.0 * p2.send(source),
-         4.0 * p3.send(source),
-         3.0 * prev(4).send(source),
-         2.0 * prev(5).send(source),
-         prev(6).send(source),].sum / 28.0
-      end
-    end
-  end
-end