quantitative 0.2.1 → 0.3.0

data/lib/quant/indicators/pivots/fibbonacci.rb

@@ -0,0 +1,22 @@
+module Quant
+  class Indicators
+    class Pivots
+      class Fibbonacci < Pivot
+        def averaging_period
+          half_period
+        end
+
+        def fibbonacci_series
+          [0.146, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0, 1.146]
+        end
+
+        def compute_bands
+          fibbonacci_series.each_with_index do |ratio, index|
+            p0[index + 1] = p0.midpoint + ratio * p0.avg_range
+            p0[-index - 1] = p0.midpoint - ratio * p0.avg_range
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/guppy.rb

@@ -0,0 +1,39 @@
+module Quant
+  class Indicators
+    class Pivots
+      class Guppy < Pivot
+        def guppy_ema(period, band)
+          return p0.input unless p1[band]
+
+          alpha = bars_to_alpha(period)
+          alpha * p0.input + (1 - alpha) * p1[band]
+        end
+
+        def compute_midpoint
+          p0.midpoint = guppy_ema(3, 0)
+        end
+
+        # The short-term MAs are typically set at 3, 5, 8, 10, 12, and 15 periods. The
+        # longer-term MAs are typically set at 30, 35, 40, 45, 50, and 60.
+        def compute
+          p0[1] = guppy_ema(5,  1)
+          p0[2] = guppy_ema(8,  2)
+          p0[3] = guppy_ema(10, 3)
+          p0[4] = guppy_ema(12, 4)
+          p0[5] = guppy_ema(15, 5)
+          p0[6] = guppy_ema(20, 6)
+          p0[7] = guppy_ema(25, 7)
+
+          p0[-1] = guppy_ema(30, -1)
+          p0[-2] = guppy_ema(35, -2)
+          p0[-3] = guppy_ema(40, -3)
+          p0[-4] = guppy_ema(45, -4)
+          p0[-5] = guppy_ema(50, -5)
+          p0[-6] = guppy_ema(60, -6)
+          p0[-7] = guppy_ema(120, -7)
+          p0[-8] = guppy_ema(200, -8)
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/keltner.rb

@@ -0,0 +1,43 @@
+module Quant
+  class Indicators
+    class Pivots
+      class Keltner < Pivot
+        depends_on Indicators::Atr
+
+        def atr_point
+          series.indicators[source].atr.points[t0]
+        end
+
+        def scale
+          5.0
+        end
+
+        def alpha
+          bars_to_alpha(min_period)
+        end
+
+        def compute_midpoint
+          p0.midpoint = alpha * p0.input + (1 - alpha) * p1.midpoint
+        end
+
+        def compute_bands
+          atr_value = atr_point.slow * scale
+
+          p0.h6 = p0.midpoint + 1.000 * atr_value
+          p0.h5 = p0.midpoint + 0.786 * atr_value
+          p0.h4 = p0.midpoint + 0.618 * atr_value
+          p0.h3 = p0.midpoint + 0.500 * atr_value
+          p0.h2 = p0.midpoint + 0.382 * atr_value
+          p0.h1 = p0.midpoint + 0.236 * atr_value
+
+          p0.l1 = p0.midpoint - 0.236 * atr_value
+          p0.l2 = p0.midpoint - 0.382 * atr_value
+          p0.l3 = p0.midpoint - 0.500 * atr_value
+          p0.l4 = p0.midpoint - 0.618 * atr_value
+          p0.l5 = p0.midpoint - 0.786 * atr_value
+          p0.l6 = p0.midpoint - 1.000 * atr_value
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/murrey.rb

@@ -0,0 +1,34 @@
+require_relative '../pivot'
+
+module Quant
+  class Indicators
+    class Pivots
+      class Murrey < Pivot
+        def multiplier
+          0.125
+        end
+
+        def compute_midpoint
+          p0.input = (p0.highest - p0.lowest) * multiplier
+          p0.midpoint = p0.lowest + (p0.input * 4.0)
+        end
+
+        def compute_bands
+          p0.h6 = p0.midpoint + p0.input * 6.0
+          p0.h5 = p0.midpoint + p0.input * 5.0
+          p0.h4 = p0.midpoint + p0.input * 4.0
+          p0.h3 = p0.midpoint + p0.input * 3.0
+          p0.h2 = p0.midpoint + p0.input * 2.0
+          p0.h1 = p0.midpoint + p0.input * 1.0
+
+          p0.l1 = p0.midpoint - p0.input * 1.0
+          p0.l2 = p0.midpoint - p0.input * 2.0
+          p0.l3 = p0.midpoint - p0.input * 3.0
+          p0.l4 = p0.midpoint - p0.input * 4.0
+          p0.l5 = p0.midpoint - p0.input * 5.0
+          p0.l6 = p0.midpoint - p0.input * 6.0
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/traditional.rb

@@ -0,0 +1,36 @@
+module Quant
+  class Indicators
+    class Pivots
+      class Traditional < Pivot
+        def multiplier
+          2.0
+        end
+
+        # Pivot Point (PP) = (High + Low + Close) / 3
+        def compute_midpoint
+          p0.midpoint = p0.input
+        end
+
+        def compute_bands
+          # Third Resistance (R3) = High + 2 × (PP - Low)
+          p0.h3 = p0.high_price + (multiplier * (p0.midpoint - p0.low_price))
+
+          # Second Resistance (R2) = PP + (High - Low)
+          p0.h2 = p0.midpoint + p0.range
+
+          # First Resistance (R1) = (2 × PP) - Low
+          p0.h1 = p0.midpoint * multiplier - p0.low_price
+
+          # First Support (S1) = (2 × PP) - High
+          p0.l1 = p0.midpoint * multiplier - p0.high_price
+
+          # Second Support (S2) = PP - (High - Low)
+          p0.l2 = p0.midpoint - p0.range
+
+          # Third Support (S3) = Low - 2 × (High - PP)
+          p0.l3 = p0.low_price - (multiplier * (p0.high_price - p0.midpoint))
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/pivots/woodie.rb

@@ -0,0 +1,59 @@
+require_relative '../pivot'
+
+module Quant
+  class Indicators
+    class Pivots
+      # One of the key differences in calculating Woodie's Pivot Point to other pivot
+      # points is that the current session's open price is used in the PP formula with
+      # the previous session's high and low. At the time-of-day that we calculate the
+      # pivot points on this site in our Daily Notes we do not have the opening price
+      # so we use the Classic formula for the Pivot Point and vary the R3 and R4
+      # formula as per Woodie's formulas.
+
+      # Formulas:
+      #   R4 = R3 + RANGE
+      #   R3 = H + 2 * (PP - L) (same as: R1 + RANGE)
+      #   R2 = PP + RANGE
+      #   R1 = (2 * PP) - LOW
+
+      #   PP = (HIGH + LOW + (TODAY'S OPEN * 2)) / 4
+      #   S1 = (2 * PP) - HIGH
+      #   S2 = PP - RANGE
+      #   S3 = L - 2 * (H - PP) (same as: S1 - RANGE)
+      #   S4 = S3 - RANGE
+      class Woodie < Pivot
+        def compute_value
+          p0.input = (t1.high_price + t1.low_price + 2.0 * t0.open_price) / 4.0
+        end
+
+        def compute_bands
+          Quant.experimental("Woodie appears erratic, is unproven and may be incorrect.")
+
+          #   R1 = (2 * PP) - LOW
+          p0.h1 = 2.0 * p0.midpoint - t1.low_price
+
+          #   R2 = PP + RANGE
+          p0.h2 = p0.midpoint + p0.range
+
+          #   R3 = H + 2 * (PP - L) (same as: R1 + RANGE)
+          p0.h3 = t1.high_price + 2.0 * (p0.midpoint - t1.low_price)
+
+          #   R4 = R3 + RANGE
+          p0.h4 = p0.h3 + p0.range
+
+          #   S1 = (2 * PP) - HIGH
+          p0.l1 = 2.0 * p0.midpoint - t1.high_price
+
+          #   S2 = PP - RANGE
+          p0.l2 = p0.midpoint - p0.range
+
+          #   S3 = L - 2 * (H - PP) (same as: S1 - RANGE)
+          p0.l3 = t1.low_price - 2.0 * (t1.high_price - p0.midpoint)
+
+          #   S4 = S3 - RANGE
+          p0.l4 = p0.l3 - p0.range
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators_source.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "dominant_cycles_source"
+module Quant
+  # {Quant::IndicatorSource} holds a collection of {Quant::Indicators::Indicator} for a given input source.
+  # This class ensures dominant cycle computations come before other indicators that depend on them.
+  #
+  # The {Quant::IndicatorSource} 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::IndicatorSource} class.
+  #
+  # By design, the {Quant::Indicators::Indicator} class holds the {Quant::Ticks::Tick} instance
+  # alongside the indicator's computed values for that tick.
+  class IndicatorsSource
+    attr_reader :series, :source, :dominant_cycles, :pivots
+
+    def initialize(series:, source:)
+      @series = series
+      @source = source
+      @indicators = {}
+      @ordered_indicators = []
+      @dominant_cycles = DominantCyclesSource.new(indicator_source: self)
+      @pivots = PivotsSource.new(indicator_source: self)
+    end
+
+    def [](indicator_class)
+      indicator(indicator_class)
+    end
+
+    def <<(tick)
+      @ordered_indicators.each { |indicator| indicator << tick }
+    end
+
+    def adx; indicator(Indicators::Adx) end
+    def atr; indicator(Indicators::Atr) end
+    def cci; indicator(Indicators::Cci) end
+    def decycler; indicator(Indicators::Decycler) end
+    def frama; indicator(Indicators::Frama) end
+    def mama; indicator(Indicators::Mama) end
+    def mesa; indicator(Indicators::Mesa) end
+    def ping; indicator(Indicators::Ping) 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 dominant_cycle
+      indicator(dominant_cycle_indicator_class)
+    end
+
+    private
+
+    attr_reader :indicators, :ordered_indicators
+
+    def dominant_cycle_indicator_class
+      Quant.config.indicators.dominant_cycle_indicator_class
+    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] ||= new_indicator(indicator_class)
+    end
+
+    # Instantiates a new indicator and adds it to the collection of indicators.
+    # This method is responsible for adding dependent indicators and the dominant cycle
+    # indicator.
+    def new_indicator(indicator_class)
+      indicator_class.new(series:, source:).tap do |indicator|
+        add_dominant_cycle_indicator(indicator.dominant_cycle_indicator_class, indicator)
+        add_dependent_indicators(indicator_class.dependent_indicator_classes, indicator)
+        add_indicator(indicator_class, indicator)
+      end
+    end
+
+    # Adds a new indicator to the collection of indicators.  Once added, every
+    # tick added to the series triggers the indicator's compute to fire.
+    # The ordered indicators list is adjusted after adding the new indicator.
+    def add_indicator(indicator_class, new_indicator)
+      return if indicators[indicator_class]
+
+      indicators[indicator_class] = new_indicator
+      @ordered_indicators = (ordered_indicators << new_indicator).sort_by(&:priority)
+      new_indicator
+    end
+
+    # Adds dependent indicators to the indicator collection.  This method is reentrant and
+    # will also add depencies of the dependent indicators.
+    # Dependent indicators automatically adjust priority based on the dependency.
+    def add_dependent_indicators(indicator_classes, indicator)
+      return if indicator_classes.empty?
+
+      # Dependent indicators should come after dominant cycle indicators, but before the
+      # indicators that depend on them.
+      dependency_priority = (Quant::Indicators::Indicator::DEPENDENCY_PRIORITY + indicator.priority) / 2
+
+      indicator_classes.each_with_index do |indicator_class, index|
+        next if indicators[indicator_class]
+
+        new_indicator = indicator_class.new(series:, source:)
+        new_indicator.define_singleton_method(:priority) { dependency_priority + index }
+        add_dependent_indicators(indicator_class.dependent_indicator_classes, new_indicator)
+        add_indicator(indicator_class, new_indicator)
+      end
+    end
+
+    # Adds the dominant cycle indicator to the collection of indicators.  Indicators added
+    # by this method must be a subclass of {Quant::Indicators::DominantCycles::DominantCycle}.
+    def add_dominant_cycle_indicator(dominant_cycle_class, indicator)
+      return if indicator.is_a?(Indicators::DominantCycles::DominantCycle)
+      return unless dominant_cycle_class
+      return if indicators[dominant_cycle_class]
+
+      dominant_cycle = dominant_cycle_class.new(series:, source:)
+      add_indicator(dominant_cycle_class, dominant_cycle)
+    end
+
+    def invalid_source_error(source:)
+      raise InvalidIndicatorSource, "Invalid indicator source: #{source.inspect}"
+    end
+  end
+end

data/lib/quant/indicators_sources.rb

@@ -1,28 +1,54 @@
 # frozen_string_literal: true
 
 module Quant
+  # {Quant::IndicatorSources} pairs a collection of {Quant::Indicators::Indicator} with an input source.
+  # This allows us to only compute indicators for the sources that are referenced at run-time.
+  # Any source explicitly used at run-time will have its indicator computed and only those indicators
+  # will be computed.
   class IndicatorsSources
+    ALL_SOURCES = [
+      PRICE_SOURCES = %i[price open_price high_price low_price close_price].freeze,
+      VOLUME_SOURCES = %i[volume base_volume target_volume].freeze,
+      COMPUTED_SOURCES = %i[oc2 hl2 hlc3 ohlc4].freeze
+    ].flatten.freeze
+
+    attr_reader :series
+
     def initialize(series:)
       @series = series
-      @indicator_sources = {}
-    end
-
-    def new_indicator(indicator)
-      @indicator_sources[indicator.source] ||= Indicators.new(series: @series, source: indicator.source)
+      @sources = {}
     end
 
     def [](source)
-      return @indicator_sources[source] if @indicator_sources.key?(source)
+      raise invalid_source_error(source:) unless ALL_SOURCES.include?(source)
 
-      raise Quant::Errors::InvalidIndicatorSource, "Invalid source, #{source.inspect}."
+      @sources[source] ||= IndicatorsSource.new(series:, source:)
     end
 
     def <<(tick)
-      @indicator_sources.each_value { |indicator| indicator << tick }
+      @sources.each_value { |indicator| indicator << tick }
+    end
+
+    ALL_SOURCES.each do |source|
+      define_method(source) do
+        @sources[source] ||= IndicatorsSource.new(series:, source:)
+      end
     end
 
-    def oc2
-      @indicator_sources[:oc2] ||= Indicators.new(series: @series, source: :oc2)
+    def respond_to_missing?(method, *)
+      oc2.respond_to?(method)
+    end
+
+    def method_missing(method_name, *args, &block)
+      return super unless respond_to_missing?(method_name)
+
+      oc2.send(method_name, *args, &block)
+    end
+
+    private
+
+    def invalid_source_error(source:)
+      raise Errors::InvalidIndicatorSource, "Invalid indicator source: #{source.inspect}"
     end
   end
 end

data/lib/quant/mixins/stochastic.rb

@@ -16,7 +16,7 @@ module Quant
       def stochastic(source, period:)
         subset = values.last(period).map{ |p| p.send(source) }
 
-        lowest, highest = subset.minimum, subset.maximum
+        lowest, highest = subset.minimum.to_f, subset.maximum.to_f
         return 0.0 if (highest - lowest).zero?
 
         100.0 * (subset[-1] - lowest) / (highest - lowest)

data/lib/quant/mixins/super_smoother.rb

@@ -2,8 +2,17 @@
 
 module Quant
   module Mixins
+    # Super Smoother Filters provide a way to smooth out the noise in a series
+    # without out introducing undesirable lag that you would other get with
+    # traditional moving averages.
+    #
+    # The EMA only reduces the amplitude at the Nyquist frequency by 13 dB.
+    # On the other hand, the SuperSmoother filter theoretically completely
+    # eliminates components at the Nyquist Frequency. The added benefit is
+    # that the SuperSmoother filter has significantly less lag than the EMA.
     module SuperSmoother
-      def two_pole_super_smooth(source, period:, previous: :ss)
+      # https://www.mesasoftware.com/papers/PredictiveIndicators.pdf
+      def two_pole_super_smooth(source, period:, previous:)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
         radians = Math.sqrt(2) * Math::PI / period
@@ -23,7 +32,7 @@ module Quant
       alias super_smoother two_pole_super_smooth
       alias ss2p two_pole_super_smooth
 
-      def three_pole_super_smooth(source, period:, previous: :ss)
+      def three_pole_super_smooth(source, period:, previous:)
         raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
 
         radians = Math::PI / period

data/lib/quant/pivots_source.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Quant
+  class PivotsSource
+    def initialize(indicator_source:)
+      @indicator_source = indicator_source
+    end
+
+    def atr; indicator(Indicators::Pivots::Atr) end
+    def bollinger; indicator(Indicators::Pivots::Bollinger) end
+    def camarilla; indicator(Indicators::Pivots::Camarilla) end
+    def classic; indicator(Indicators::Pivots::Classic) end
+    def demark; indicator(Indicators::Pivots::Demark) end
+    def donchian; indicator(Indicators::Pivots::Donchian) end
+    def fibbonacci; indicator(Indicators::Pivots::Fibbonacci) end
+    def guppy; indicator(Indicators::Pivots::Guppy) end
+    def keltner; indicator(Indicators::Pivots::Keltner) end
+    def murrey; indicator(Indicators::Pivots::Murrey) end
+    def traditional; indicator(Indicators::Pivots::Traditional) end
+    def woodie; indicator(Indicators::Pivots::Woodie) end
+
+    private
+
+    def indicator(indicator_class)
+      @indicator_source[indicator_class]
+    end
+  end
+end

data/lib/quant/refinements/array.rb

@@ -103,6 +103,7 @@ module Quant
 
       # Computes the mean of the array.  When +n+ is specified, the mean is computed over
       # the last +n+ elements, otherwise it is computed over the entire array.
+      # If the array is empty, 0.0 is returned.
       #
       # @param n [Integer] the number of elements to compute the mean over
       # @return [Float]
@@ -113,6 +114,19 @@ module Quant
         subset.sum / subset.size.to_f
       end
 
+      # Returns the largest absolute value in the array.  When +n+ is specified, the peak is computed over
+      # the last +n+ elements, otherwise it is computed over the entire array.
+      # If the array is empty, 0.0 is returned.
+      #
+      # @param n [Integer] the number of elements to compute the peak over
+      # @return [Float]
+      def peak(n: size)
+        subset = last(n)
+        return 0.0 if subset.empty?
+
+        [subset.max.abs, subset.min.abs].max
+      end
+
       # Computes the Exponential Moving Average (EMA) of the array.  When +n+ is specified,
       # the EMA is computed over the last +n+ elements, otherwise it is computed over the entire array.
       # An Array of EMA's is returned, with the first entry always the first value in the subset.

data/lib/quant/series.rb

@@ -60,18 +60,20 @@ module Quant
       @ticks = []
     end
 
-    def limit_iterations(start_iteration, stop_iteration)
-      selected_ticks = ticks[start_iteration..stop_iteration]
+    def build_limited_series(selected_ticks)
       return self if selected_ticks.size == ticks.size
 
       self.class.from_ticks(symbol:, interval:, ticks: selected_ticks)
     end
 
+    def limit_iterations(start_iteration, stop_iteration)
+      selected_ticks = ticks[start_iteration..stop_iteration]
+      build_limited_series 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:, interval:, ticks: selected_ticks)
+      build_limited_series selected_ticks
     end
 
     def_delegator :@ticks, :[]
@@ -80,6 +82,7 @@ module Quant
     def_delegator :@ticks, :select!
     def_delegator :@ticks, :reject!
     def_delegator :@ticks, :last
+    def_delegator :@ticks, :take
 
     def highest
       ticks.max_by(&:high_price)
@@ -101,20 +104,6 @@ module Quant
       "#<#{self.class.name} symbol=#{symbol} interval=#{interval} ticks=#{ticks.size}>"
     end
 
-    # When the first indicator is instantiated, it will also lead to instantiating
-    # the dominant cycle indicator.  The `new_indicator_lock` prevents reentrant calls
-    # to the `new_indicator` method with infinite recursion.
-    def new_indicator(indicator)
-      return if @new_indicator_lock
-
-      begin
-        @new_indicator_lock = true
-        indicators.new_indicator(indicator)
-      ensure
-        @new_indicator_lock = false
-      end
-    end
-
     def <<(tick)
       tick = Ticks::Spot.new(price: tick) if tick.is_a?(Numeric)
       indicators << tick unless tick.series?

data/lib/quant/settings/indicators.rb

@@ -59,6 +59,7 @@ module Quant
         @half_period = settings[:half_period] || compute_half_period
         @micro_period = settings[:micro_period] || Settings::MICRO_PERIOD
 
+        @dominant_cycle_indicator_class = nil
         @dominant_cycle_kind = settings[:dominant_cycle_kind] || Settings::DOMINANT_CYCLE_KINDS.first
         @pivot_kind = settings[:pivot_kind] || Settings::PIVOT_KINDS.first
       end
@@ -68,6 +69,7 @@ module Quant
         @min_period = settings.fetch(:min_period, @min_period)
         compute_half_period
         @micro_period = settings.fetch(:micro_period, @micro_period)
+        @dominant_cycle_indicator_class = nil
         @dominant_cycle_kind = settings.fetch(:dominant_cycle_kind, @dominant_cycle_kind)
         @pivot_kind = settings.fetch(:pivot_kind, @pivot_kind)
       end
@@ -83,6 +85,15 @@ module Quant
       def compute_half_period
         @half_period = (max_period + min_period) / 2
       end
+
+      def dominant_cycle_indicator_class
+        return @dominant_cycle_indicator_class if @dominant_cycle_indicator_class
+
+        base_class_name = dominant_cycle_kind.to_s.split("_").map(&:capitalize).join
+        class_name = "Quant::Indicators::DominantCycles::#{base_class_name}"
+
+        @dominant_cycle_indicator_class = Object.const_get(class_name)
+      end
     end
   end
 end

data/lib/quant/version.rb

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

data/quantitative.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/quant/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "quantitative"
+  spec.version = Quant::VERSION
+  spec.authors = ["Michael Lang"]
+  spec.email = ["mwlang@cybrains.net"]
+
+  spec.summary = "Quantitative and statistical tools written for Ruby 3.2+ for trading and finance."
+  spec.description = spec.summary
+  spec.homepage = "https://github.com/mwlang/quantitative"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "oj", "~> 3.10"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end