quantitative 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72d65b65fdcbb81650fcce3233f3fbde9c99c4b9b9ace1ce3bbc3b8e565152f9
-  data.tar.gz: f687ab3c32e88ffc579a9f92ff428846f91e60ff166d3b4379963deb15a88425
+  metadata.gz: 7491465248d383f459899467e14c9bafa16376f8fe7dc2cac657fca8a9170200
+  data.tar.gz: 956074c17983ee22d6480a176c48b0cc15257aaca2649086eacc71a52688cb12
 SHA512:
-  metadata.gz: 594d57a819ce8d561c064f685353d27ef4dfd1cb2e76e5cf07758bcedb1c501d2bc06859aff89cf6f4bc744e327ede1290e31b4d4ffb1daed99d614735eb0a76
-  data.tar.gz: 5fbfb29d1501a3562788abf83ef4fcb78bcb17fcfc030e7543b42f3c29c2a7a5c3c8fba187494d4655691e117e383af59bca428764f49fd7e41fcef911ef6d40
+  metadata.gz: 0f932bc68ca6f3e47261aaf2d19b34465b0f242bc13b5935ab55c0eea0ee736b0ea183b4bacc6a99d9beecd9a2457dd07957a639bd2d85e35f0a5584b35c2f2a
+  data.tar.gz: c0baa0af0133cbdd46439fc0ce8d068a583f05688371025275afe4297d0bd01a7aad90c4f3ebae98afaa1a4b28b56e43fa2aa68aaafc018bd34e22ec037d1b07

data/.rubocop.yml

@@ -2,7 +2,7 @@ inherit_gem:
   relaxed-rubocop: .rubocop.yml
 
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.2
   Exclude:
     - 'spec/performance/*.rb'
 

data/Gemfile

@@ -18,3 +18,7 @@ gem "guard-rspec", "~> 4.7"
 gem "yard", "~> 0.9"
 gem "benchmark-ips", "~> 2.9"
 
+gem 'rspec-github'
+gem 'simplecov'
+gem 'simplecov-cobertura'
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.1.6)
+    quantitative (0.1.8)
       oj (~> 3.10)
 
 GEM
@@ -15,6 +15,7 @@ GEM
       irb (>= 1.5.0)
       reline (>= 0.3.1)
     diff-lcs (1.5.0)
+    docile (1.4.0)
     ffi (1.16.3)
     formatador (1.1.0)
     guard (2.18.1)
@@ -79,6 +80,8 @@ GEM
     rspec-expectations (3.12.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
+    rspec-github (2.4.0)
+      rspec-core (~> 3.0)
     rspec-mocks (3.12.6)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
@@ -106,6 +109,15 @@ GEM
       rubocop-factory_bot (~> 2.22)
     ruby-progressbar (1.13.0)
     shellany (0.0.1)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-cobertura (2.1.0)
+      rexml
+      simplecov (~> 0.19)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
     stringio (3.1.0)
     thor (1.3.0)
     unicode-display_width (2.5.0)
@@ -113,6 +125,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-22
+  x86_64-linux
 
 DEPENDENCIES
   benchmark-ips (~> 2.9)
@@ -122,8 +135,11 @@ DEPENDENCIES
   rake (~> 13.0)
   relaxed-rubocop
   rspec (~> 3.0)
+  rspec-github
   rubocop (~> 1.21)
   rubocop-rspec
+  simplecov
+  simplecov-cobertura
   yard (~> 0.9)
 
 BUNDLED WITH

data/README.md

@@ -1,10 +1,10 @@
 # Quantitative
 
-[![Gem Version](https://badge.fury.io/rb/quantitative.svg)](https://badge.fury.io/rb/quantitative)
+[![Gem Version](https://badge.fury.io/rb/quantitative.svg)](https://badge.fury.io/rb/quantitative) [![codecov](https://codecov.io/gh/mwlang/quantitative/graph/badge.svg?token=ZXMSKQZKD5)](https://codecov.io/gh/mwlang/quantitative)
 
 STATUS: ALPHA - very early stages!  The framework is very much a work in progress and I am rapidly introducing new things and changing existing things around.
 
-Quantitative is a statistical and quantitative library for Ruby 3.x for trading stocks, cryptocurrency, and forex.  It provides a number of classes and modules for working with time-series data, financial data, and other quantitative data.  It is designed to be fast, efficient, and easy to use.
+Quantitative is a statistical and quantitative library for Ruby 3.2+ for trading stocks, cryptocurrency, and forex.  It provides a number of classes and modules for working with time-series data, financial data, and other quantitative data.  It is designed to be fast, efficient, and easy to use.
 
 It has been highly optimized for fairly high-frequency trading purely in Ruby (no external numerical/statistical native extensions).  The one exception is that I opted to depend on `Oj` which is a high-performant JSON parser that greatly speeds up serializing data between disk and memory.  In practice, Quantitative is performant enough to trade one minute tickers on down to 30 second ticks for around 100 or so ticker symbols.  Trading anything lower depends on the amount of analysis you're doing and your mileage may vary.  It is possible, but you will find yourself with tradeoffs between the amount of data you can crunch and how fast you can react to live trading situations.
 
@@ -46,6 +46,18 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/mwlang/quantitative. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/mwlang/quantitative/blob/main/CODE_OF_CONDUCT.md).
 
+The Relaxed Ruby Style Guide is adopted for RuboCop.
+
+### Keeping Test Coverage High
+
+TDD/BDD is fully embraced for this project.  If you opt to contribute, please include tests to coverage new features and behavior tests.
+
+RSpec is the test framework. SimpleCov is used for coverage reports.
+
+### Test Driven / Behavior Driven development Coverage Map:
+
+![Coverage Map](https://codecov.io/gh/mwlang/quantitative/graphs/sunburst.svg?token=ZXMSKQZKD5)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/quant/asset.rb

@@ -82,7 +82,7 @@ module Quant
     end
 
     def to_json(*args, full: false)
-      Oj.dump(to_h(full: full), *args)
+      Oj.dump(to_h(full:), *args)
     end
   end
 end

data/lib/quant/attributes.rb

@@ -93,7 +93,7 @@ module Quant
       end
 
       registry[klass] ||= {}
-      registry[klass][name] = { key: key, default: default }
+      registry[klass][name] = { key:, default: }
     end
 
     module InstanceMethods
@@ -138,7 +138,7 @@ module Quant
         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])
+        elsif entry[:default].is_a?(Symbol) && current_tick.respond_to?(entry[:default])
           current_tick.send(entry[:default])
 
         elsif entry[:default].is_a?(Proc)

data/lib/quant/indicators/indicator.rb

@@ -4,10 +4,9 @@ module Quant
   class Indicators
     class Indicator
       include Enumerable
-
-      # # include Mixins::TrendMethods
-      # include Mixins::Trig
-      # include Mixins::WeightedAverage
+      include Mixins::Functions
+      include Mixins::Filters
+      include Mixins::MovingAverages
       # include Mixins::HilbertTransform
       # include Mixins::SuperSmoother
       # include Mixins::Stochastic
@@ -46,7 +45,7 @@ module Quant
 
       def <<(tick)
         @t0 = tick
-        @p0 = points_class.new(tick: tick, source: source)
+        @p0 = points_class.new(tick:, source:)
         @points[tick] = @p0
 
         @p1 = values[-2] || @p0

data/lib/quant/indicators/indicator_point.rb

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

data/lib/quant/indicators_proxy.rb

@@ -25,7 +25,7 @@ module Quant
     # 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)
+      indicators[indicator_class] ||= indicator_class.new(series:, source:)
     end
 
     # Adds the tick to all active indicators, triggering them to compute

data/lib/quant/mixins/butterworth_filters.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module ButterworthFilters
+      def two_pole_butterworth(source, period:, previous: :bw)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        v0 = p0.send(source)
+
+        v1 = 0.5 * (v0 + p1.send(source))
+        v2 = p1.send(previous)
+        v3 = p2.send(previous)
+
+        radians = Math.sqrt(2) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+
+        c2 = b
+        c3 = -a**2
+        c1 = 1.0 - c2 - c3
+
+        (c1 * v1) + (c2 * v2) + (c3 * v3)
+      end
+
+      def three_pole_butterworth(source, period:, previous: :bw)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        v0 = p0.send(source)
+        v1 = p1.send(previous)
+        v2 = p2.send(previous)
+        v3 = p3.send(previous)
+
+        radians = Math.sqrt(3) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+        c = a**2
+
+        d4 = c**2
+        d3 = -(c + (b * c))
+        d2 = b + c
+        d1 = 1.0 - d2 - d3 - d4
+
+        (d1 * v0) + (d2 * v1) + (d3 * v2) + (d4 * v3)
+      end
+    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,114 +1,51 @@
 # frozen_string_literal: true
 
-require_relative "trig"
-
 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
-
-      def ema(source, prev_source, period)
-        alpha = bars_to_alpha(period)
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
-        v1 = p1.send(prev_source)
-        (v0 * alpha) + (v1 * (1 - alpha))
-      end
-
-      def band_pass(source, prev_source, period, bandwidth); end
-
-      def two_pole_butterworth(source, prev_source, period)
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
-
-        v1 = 0.5 * (v0 + p1.send(source))
-        v2 = p1.send(prev_source)
-        v3 = p2.send(prev_source)
-
-        radians = Math.sqrt(2) * Math::PI / period
-        a = Math.exp(-radians)
-        b = 2 * a * Math.cos(radians)
-
-        c2 = b
-        c3 = -a**2
-        c1 = 1.0 - c2 - c3
-
-        (c1 * v1) + (c2 * v2) + (c3 * v3)
-      end
-
-      def three_pole_butterworth(source, prev_source, period)
-        v0 = source.is_a?(Symbol) ? p0.send(source) : source
-        return v0 if p2 == p3
-
-        v1 = p1.send(prev_source)
-        v2 = p2.send(prev_source)
-        v3 = p3.send(prev_source)
-
-        radians = Math.sqrt(3) * Math::PI / period
-        a = Math.exp(-radians)
-        b = 2 * a * Math.cos(radians)
-        c = a**2
-
-        d4 = c**2
-        d3 = -(c + (b * c))
-        d2 = b + c
-        d1 = 1.0 - d2 - d3 - d4
-
-        (d1 * v0) + (d2 * v1) + (d3 * v2) + (d4 * v3)
-      end
+      include Mixins::ButterworthFilters
     end
   end
 end

data/lib/quant/mixins/fisher_transform.rb

@@ -3,36 +3,45 @@
 module Quant
   module Mixins
     # Fisher Transforms
-    # • Price is not a Gaussian (Bell Curve) distribution, even though many technical analysis formulas
-    #   falsely assume that it is. Bell Curve tails are missing.
-    #   – If $10 stock were Gaussian, it could go up or down $20 – Standard deviation based indicators like Bollinger Bands
-    #   and zScore make the Gaussian assumption error
-    # • TheFisher Transform converts almost any probability distribution in a Gaussian-like one
-    #   – Expands the distribution and creates tails
-    # • The Inverse Fisher Transform converts almost any probability distribution into a square wave
-    #   – Compresses, removes low amplitude variations
+    # • Price is not a Gaussian (Bell Curve) distribution, even though many
+    #   technical analysis formulas falsely assume that it is. Bell Curve tails
+    #   are missing.
+    #     – If $10 stock were Gaussian, it could go up or down $20
+    #     – Standard deviation based indicators like Bollinger Bands
+    #       and zScore make the Gaussian assumption error
+    #
+    # • TheFisher Transform converts almost any probability distribution
+    #   in a Gaussian-like one
+    #     – Expands the distribution and creates tails
+    #
+    # • The Inverse Fisher Transform converts almost any probability
+    #   distribution into a square wave
+    #     – Compresses, removes low amplitude variations
     module FisherTransform
       # inverse fisher transform
       # https://www.mql5.com/en/articles/303
-      def ift(value, scale_factor = 1.0)
+      def inverse_fisher_transform(value, scale_factor: 1.0)
         r = (Math.exp(2.0 * scale_factor * value) - 1.0) / (Math.exp(2.0 * scale_factor * value) + 1.0)
         r.nan? ? 0.0 : r
       end
+      alias ift inverse_fisher_transform
 
-      # def fisher_transform(value, max_value)
-      #   return 0.0 if max_value.zero?
-      #   x = (value / max_value).abs
-      #   r = 0.5 * Math.log((1 + x) / (1 - x))
-      #   r.nan? ? 0.0 : r
-      # end
+      def relative_fisher_transform(value, max_value:)
+        max_value.zero? ? 0.0 : fisher_transform(value / max_value)
+      end
+      alias rft relative_fisher_transform
 
       # The absolute value passed must be < 1.0
       def fisher_transform(value)
-        r = 0.5 * Math.log((1.0 + value) / (1.0 - value))
-        r.nan? ? 0.0 : r
+        raise ArgumentError, "value (#{value}) must be between -1.0 and 1.0" unless value.abs <= 1.0
+
+        result = 0.5 * Math.log((1.0 + value) / (1.0 - value))
+        result.nan? ? 0.0 : result
       rescue Math::DomainError => e
-        raise "value #{value}: #{(1 + value) / (1 - value)}, e: #{e}"
+        raise Math::DomainError, "#{e.message}: cannot take the Log of #{value}: #{(1 + value) / (1 - value)}"
       end
+      alias fisher fisher_transform
+      alias ft fisher_transform
     end
   end
 end

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

@@ -3,11 +3,11 @@
 module Quant
   module Mixins
     module HilbertTransform
-      def hilbert_transform(source, period = p1.period)
+      def hilbert_transform(source, period:)
         [0.0962 * p0.send(source),
          0.5769 * p2.send(source),
-         -0.5769 * prev(4).send(source),
-         -0.0962 * prev(6).send(source),].sum * ((0.075 * period) + 0.54)
+         -0.5769 * p(4).send(source),
+         -0.0962 * p(6).send(source),].sum * ((0.075 * period) + 0.54)
       end
     end
   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/refinements/array.rb

@@ -176,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:)**0.5
       end
 
       def variance(reference_value, n: size)

data/lib/quant/series.rb

@@ -19,7 +19,7 @@ module Quant
       raise "File #{filename} does not exist" unless File.exist?(filename)
 
       ticks = File.read(filename).split("\n").map{ |line| Oj.load(line) }
-      from_hash symbol: symbol, interval: interval, hash: ticks, serializer_class: serializer_class
+      from_hash symbol:, interval:, hash: ticks, serializer_class:
     end
 
     # Loads a series of ticks when the JSON string represents an array of ticks.
@@ -29,8 +29,8 @@ module Quant
     # @param json [String] The JSON string to parse into ticks.
     # @param serializer_class [Class] {Quant::Ticks::TickSerializer} class to use for the conversion.
     def self.from_json(symbol:, interval:, json:, serializer_class: nil)
-      ticks = Oj.load(json)
-      from_hash symbol: symbol, interval: interval, hash: ticks, serializer_class: serializer_class
+      hash = Oj.load(json)
+      from_hash symbol:, interval:, hash:, serializer_class:
     end
 
     # Loads a series of ticks where the hash must be cast to an array of {Quant::Ticks::Tick} objects.
@@ -39,15 +39,15 @@ module Quant
     # @param hash [Array<Hash>] The array of hashes to convert to {Quant::Ticks::Tick} objects.
     # @param serializer_class [Class] {Quant::Ticks::TickSerializer} class to use for the conversion.
     def self.from_hash(symbol:, interval:, hash:, serializer_class: nil)
-      ticks = hash.map { |tick_hash| Quant::Ticks::OHLC.from(tick_hash, serializer_class: serializer_class) }
-      from_ticks symbol: symbol, interval: interval, ticks: ticks
+      ticks = hash.map { |tick_hash| Quant::Ticks::OHLC.from(tick_hash, serializer_class:) }
+      from_ticks symbol:, interval:, ticks:
     end
 
     # Loads a series of ticks where the array represents an array of {Quant::Ticks::Tick} objects.
     def self.from_ticks(symbol:, interval:, ticks:)
       ticks = ticks.sort_by(&:close_timestamp)
 
-      new(symbol: symbol, interval: interval).tap do |series|
+      new(symbol:, interval:).tap do |series|
         ticks.each { |tick| series << tick }
       end
     end
@@ -64,14 +64,14 @@ module Quant
       selected_ticks = ticks[start_iteration..stop_iteration]
       return self if selected_ticks.size == ticks.size
 
-      self.class.from_ticks(symbol: symbol, interval: interval, ticks: selected_ticks)
+      self.class.from_ticks(symbol:, interval:, ticks: selected_ticks)
     end
 
     def limit(period)
       selected_ticks = ticks.select{ |tick| period.cover?(tick.close_timestamp) }
       return self if selected_ticks.size == ticks.size
 
-      self.class.from_ticks(symbol: symbol, interval: interval, ticks: selected_ticks)
+      self.class.from_ticks(symbol:, interval:, ticks: selected_ticks)
     end
 
     def_delegator :@ticks, :[]
@@ -94,7 +94,7 @@ module Quant
     end
 
     def dup
-      self.class.from_ticks(symbol: symbol, interval: interval, ticks: ticks)
+      self.class.from_ticks(symbol:, interval:, ticks:)
     end
 
     def inspect

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/serializers/ohlc.rb

@@ -3,7 +3,7 @@
 module Quant
   module Ticks
     module Serializers
-      module OHLC
+      class OHLC < Tick
         # Returns a +Quant::Ticks::Tick+ from a valid JSON +String+.
         # @param json [String]
         # @param tick_class [Quant::Ticks::Tick]
@@ -13,7 +13,7 @@ module Quant
         #  Quant::Ticks::Serializers::Tick.from_json(json, tick_class: Quant::Ticks::Spot)
         def self.from_json(json, tick_class:)
           hash = Oj.load(json)
-          from(hash, tick_class: tick_class)
+          from(hash, tick_class:)
         end
 
         # Instantiates a tick from a +Hash+.  The hash keys are expected to be the same as the serialized keys.

data/lib/quant/ticks/serializers/spot.rb

@@ -13,7 +13,7 @@ module Quant
         #  Quant::Ticks::Serializers::Tick.from_json(json, tick_class: Quant::Ticks::Spot)
         def self.from_json(json, tick_class:)
           hash = Oj.load(json)
-          from(hash, tick_class: tick_class)
+          from(hash, tick_class:)
         end
 
         # Returns a +Hash+ of the Spot tick's key properties

data/lib/quant/ticks/serializers/tick.rb

@@ -69,7 +69,7 @@ module Quant
         #  Quant::Ticks::Serializers::Tick.from_json(json, tick_class: Quant::Ticks::Spot)
         def self.from_json(json, tick_class:)
           hash = Oj.load(json)
-          from(hash, tick_class: tick_class)
+          from(hash, tick_class:)
         end
       end
     end

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.
@@ -109,7 +120,7 @@ module Quant
       #   tick.to_csv(headers: true)
       #   # => "timestamp,price,volume\n2018-01-01 12:00:00 UTC,100.0,1000\n"
       def to_csv(serializer_class: default_serializer_class, headers: false)
-        serializer_class.to_csv(self, headers: headers)
+        serializer_class.to_csv(self, headers:)
       end
 
       # Reflects the serializer class from the tick's class name.

data/lib/quant/time_period.rb

@@ -72,7 +72,7 @@ module Quant
     end
 
     def to_h
-      { start_at: start_at, end_at: end_at }
+      { start_at:, end_at: }
     end
   end
 end

data/lib/quant/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-25 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -24,8 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
-description: Quantitative and statistical tools written for Ruby 3.x for trading and
-  finance.
+description: Quantitative and statistical tools written for Ruby 3.2+ for trading
+  and finance.
 email:
 - mwlang@cybrains.net
 executables: []
@@ -57,15 +57,19 @@ files:
 - lib/quant/indicators_proxy.rb
 - lib/quant/indicators_sources.rb
 - lib/quant/interval.rb
+- lib/quant/mixins/butterworth_filters.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
@@ -96,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -106,5 +110,6 @@ requirements: []
 rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
-summary: Quantitative and statistical tools written for Ruby 3.x for trading and finance.
+summary: Quantitative and statistical tools written for Ruby 3.2+ for trading and
+  finance.
 test_files: []