quantitative 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5786b75635cde82e7919fce6b8fcd568724b27fc2810efe6db36a7e6dd09cc
-  data.tar.gz: 3a6fb86c25bb4f2b1e4994710539bfb528377ef57531e6845a4417c87fc86e29
+  metadata.gz: 0cfda18120bf7e3432b359a53d19d633f70f66e3ea4468098673cfc89ac2f77e
+  data.tar.gz: 598dc565f6da96ce9565afee249f38bc909234177d7b484ce82cba226e2e8d60
 SHA512:
-  metadata.gz: 5ae30c5b971d6c7bd41e3c2b764e7d95438931790271133dc0e3a476a371affddfdcf06355ffa933240c0c9952fd8fa5e4212c496c95c80f028de7399d3b129f
-  data.tar.gz: 9ff8aeaf24800a7208e51f836dd7c7c3621b2e2e3a7f1e8820d89f6fc5cd56dd3c4b762c478d221c6ef7279f62c0df75ae1a19f6a4d34e7ba82e116e6a10a790
+  metadata.gz: 5b2625954abe0e72a776de95da8d26af213440cb7e2d7beddd48529dfdb70d7247562066b09a3edd1dd3f171ad3ff8a32390ffe337729ca9712f65bdb147084e
+  data.tar.gz: 780f81a808f14d2d63b53aa81f8f30920b252979f17409d1ba48105ed5eadc91dadc253ada0cd75c6c21b8e6a8450cf39c75ce542adb450759fb097679899cce

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    quantitative (0.2.2)
+    quantitative (0.3.1)
       oj (~> 3.10)
+      zeitwerk (~> 2.6)
 
 GEM
   remote: https://rubygems.org/
@@ -126,6 +127,7 @@ GEM
     unicode-display_width (2.5.0)
     vernier (0.5.1)
     yard (0.9.34)
+    zeitwerk (2.6.15)
 
 PLATFORMS
   arm64-darwin-22

data/README.md

@@ -22,6 +22,11 @@ The information provided by this library should not be construed as an endorseme
 
 Past performance is not necessarily indicative of future results. By using this library, you agree that the developers and contributors will not be liable for any losses or damages arising from your use of the library. Use at your own risk.
 
+## Possibilties
+While charting and automated trading systems are not part of this library, Quantitative goes a long ways towards giving you powerful tools to build such a system.  It is extracted from an automated trading system built in Ruby on Rails and has been used to generate considerable net profits over the years.
+
+![Possibilities](https://github.com/mwlang/quantitative/blob/main/possibilities.png)
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/lib/quant/asset.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "asset_class"
-
 module Quant
   # A {Quant::Asset} is a representation of a financial instrument such as a stock, option, future, or currency.
   # It is used to represent the instrument that is being traded, analyzed, or managed.

data/lib/quant/{dominant_cycle_indicators.rb → dominant_cycles_source.rb}

@@ -1,6 +1,4 @@
 
-require_relative 'indicators_proxy'
-
 module Quant
   # Dominant Cycles measure the primary cycle within a given range.  By default, the library
   # is wired to look for cycles between 10 and 48 bars.  These values can be adjusted by setting
@@ -16,7 +14,11 @@ module Quant
   # The purpose of these indicators is to compute the dominant cycle and underpin the various
   # indicators that would otherwise be setting an arbitrary lookback period.  This makes the
   # indicators adaptive and auto-tuning to the market dynamics.  Or so the theory goes!
-  class DominantCycleIndicators < IndicatorsProxy
+  class DominantCyclesSource
+    def initialize(indicator_source:)
+      @indicator_source = indicator_source
+    end
+
     # Auto-Correlation Reversals is a method of computing the dominant cycle
     # by correlating the data stream with itself delayed by a lag.
     def acr; indicator(Indicators::DominantCycles::Acr) end
@@ -28,11 +30,6 @@ module Quant
     # and this is the `period` of the dominant cycle.
     def band_pass; indicator(Indicators::DominantCycles::BandPass) end
 
-    # Homodyne means the signal is multiplied by itself. More precisely,
-    # we want to multiply the signal of the current bar with the complex
-    # value of the signal one bar ago
-    def homodyne; indicator(Indicators::DominantCycles::Homodyne) end
-
     # The Dual Differentiator algorithm computes the phase angle from the
     # analytic signal as the arctangent of the ratio of the imaginary
     # component to the real component. Further, the angular frequency
@@ -40,13 +37,24 @@ module Quant
     # derive the cycle period.
     def differential; indicator(Indicators::DominantCycles::Differential) end
 
+    # Static, arbitrarily set period.
+    def half_period; indicator(Indicators::DominantCycles::HalfPeriod) end
+
+    # Homodyne means the signal is multiplied by itself. More precisely,
+    # we want to multiply the signal of the current bar with the complex
+    # value of the signal one bar ago
+    def homodyne; indicator(Indicators::DominantCycles::Homodyne) end
+
     # The phase accumulation method of computing the dominant cycle measures
     # the phase at each sample by taking the arctangent of the ratio of the
     # quadrature component to the in-phase component.  The phase is then
     # accumulated and the period is derived from the phase.
     def phase_accumulator; indicator(Indicators::DominantCycles::PhaseAccumulator) end
 
-    # Static, arbitrarily set period.
-    def half_period; indicator(Indicators::DominantCycles::HalfPeriod) end
+    private
+
+    def indicator(indicator_class)
+      @indicator_source[indicator_class]
+    end
   end
 end

data/lib/quant/experimental.rb

@@ -1,14 +1,23 @@
 # frozen_string_literal: true
 
 module Quant
+  # {Quant::Experimental} is an alert emitter for experimental code paths.
+  # It will typically be used for new indicators or computations that are not yet
+  # fully vetted or tested.
   module Experimental
     def self.tracker
       @tracker ||= {}
     end
+
+    def self.rspec_defined?
+      defined?("RSpec")
+    end
   end
 
-  def self.experimental(message)
-    return if defined?(RSpec)
+  module_function
+
+  def experimental(message)
+    return if Experimental.rspec_defined?
     return if Experimental.tracker[caller.first]
 
     Experimental.tracker[caller.first] = message

data/lib/quant/indicators/adx.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "indicator_point"
-require_relative "indicator"
-
 module Quant
-  class Indicators
+  module Indicators
     class AdxPoint < IndicatorPoint
       attribute :dmu, default: 0.0
       attribute :dmd, default: 0.0
@@ -24,6 +21,8 @@ module Quant
     end
 
     class Adx < Indicator
+      depends_on Indicators::Atr
+
       def alpha
         bars_to_alpha(dc_period)
       end

data/lib/quant/indicators/atr.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "indicator_point"
-require_relative "indicator"
-
 module Quant
-  class Indicators
+  module Indicators
     class AtrPoint < IndicatorPoint
       attribute :tr, default: 0.0
       attribute :period, default: :min_period

data/lib/quant/indicators/cci.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     class CciPoint < IndicatorPoint
       attribute :hp, default: 0.0
       attribute :real, default: 0.0

data/lib/quant/indicators/decycler.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     # The decycler oscillator can be useful for determining the transition be- tween uptrends and downtrends by the crossing of the zero
     # line. Alternatively, the changes of slope of the decycler oscillator are easier to identify than the changes in slope of the
     # original decycler. Optimum cutoff periods can easily be found by experimentation.
@@ -14,25 +14,13 @@ module Quant
     #    output of another high-pass filter having a longer cutoff period.
     # 5. A decycler oscillator shows transitions between uptrends and down-trends at the zero crossings.
     class DecyclerPoint < IndicatorPoint
-      attr_accessor :decycle, :hp1, :hp2, :osc, :peak, :agc, :ift
-
-      def to_h
-        {
-          "dc" => decycle,
-          "hp1" => hp1,
-          "hp2" => hp2,
-          "osc" => osc,
-        }
-      end
-
-      def initialize_data_points(indicator:)
-        @decycle = oc2
-        @hp1 = 0.0
-        @hp2 = 0.0
-        @osc = 0.0
-        @peak = 0.0
-        @agc = 0.0
-      end
+      attribute :decycle, default: :input
+      attribute :hp1, default: 0.0
+      attribute :hp2, default: 0.0
+      attribute :osc, default: 0.0
+      attribute :peak, default: 0.0
+      attribute :agc, default: 0.0
+      attribute :ift, default: 0.0
     end
 
     class Decycler < Indicator
@@ -40,13 +28,9 @@ module Quant
         dc_period
       end
 
-      def min_period
-        settings.min_period
-      end
-
       def compute_decycler
         alpha = period_to_alpha(max_period)
-        p0.decycle = (alpha / 2) * (p0.oc2 + p1.oc2) + (1.0 - alpha) * p1.decycle
+        p0.decycle = (alpha / 2) * (p0.input + p1.input) + (1.0 - alpha) * p1.decycle
       end
 
       # alpha1 = (Cosine(.707*360 / HPPeriod1) + Sine (.707*360 / HPPeriod1) - 1) / Cosine(.707*360 / HPPeriod1);
@@ -56,7 +40,7 @@ module Quant
         c = Math.cos(0.707 * radians / period)
         s = Math.sin(0.707 * radians / period)
         alpha = (c + s - 1) / c
-        (1 - alpha / 2)**2 * (p0.oc2 - 2 * p1.oc2 + p2.oc2) + 2 * (1 - alpha) * p1.send(hp) - (1 - alpha) * (1 - alpha) * p2.send(hp)
+        (1 - alpha / 2)**2 * (p0.input - 2 * p1.input + p2.input) + 2 * (1 - alpha) * p1.send(hp) - (1 - alpha) * (1 - alpha) * p2.send(hp)
       end
 
       def compute_oscillator
@@ -65,20 +49,22 @@ module Quant
         p0.osc = p0.hp2 - p0.hp1
       end
 
-      def compute_agc
+      # AGC is constrained to -1.0 to 1.0
+      # The peak decays at a rate of 0.991 per bar
+      def compute_automatic_gain_control
         p0.peak = [p0.osc.abs, 0.991 * p1.peak].max
         p0.agc = p0.peak.zero? ? p0.osc : p0.osc / p0.peak
       end
 
-      def compute_ift
-        p0.ift = ift(p0.agc, 5.0)
+      def compute_inverse_fisher_transform
+        p0.ift = inverse_fisher_transform(p0.agc, scale_factor: 5.0)
       end
 
       def compute
         compute_decycler
         compute_oscillator
-        compute_agc
-        compute_ift
+        compute_automatic_gain_control
+        compute_inverse_fisher_transform
       end
     end
   end

data/lib/quant/indicators/dominant_cycles/acr.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../indicator_point"
-require_relative "dominant_cycle"
-
 module Quant
-  class Indicators
-    class DominantCycles
-      class AcrPoint < DominantCyclePoint
+  module Indicators
+    module DominantCycles
+      class AcrPoint < Quant::Indicators::IndicatorPoint
         attribute :hp, default: 0.0
         attribute :filter, default: 0.0
         attribute :interim_period, default: 0.0

data/lib/quant/indicators/dominant_cycles/band_pass.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "dominant_cycle"
-
 module Quant
-  class Indicators
-    class DominantCycles
+  module Indicators
+    module DominantCycles
       class BandPassPoint < Quant::Indicators::IndicatorPoint
         attribute :hp, default: 0.0
         attribute :bp, default: 0.0

data/lib/quant/indicators/dominant_cycles/differential.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
-    class DominantCycles
+  module Indicators
+    module DominantCycles
       # The Dual Differentiator algorithm computes the phase angle from the
       # analytic signal as the arctangent of the ratio of the imaginary
       # component to the real component. Further, the angular frequency

data/lib/quant/indicators/dominant_cycles/dominant_cycle.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../indicator"
-
 module Quant
-  class Indicators
+  module Indicators
     # Dominant Cycles measure the primary cycle within a given range.  By default, the library
     # is wired to look for cycles between 10 and 48 bars.  These values can be adjusted by setting
     # the `min_period` and `max_period` configuration values in {Quant::Config}.
@@ -18,7 +16,7 @@ module Quant
     # The purpose of these indicators is to compute the dominant cycle and underpin the various
     # indicators that would otherwise be setting an arbitrary lookback period.  This makes the
     # indicators adaptive and auto-tuning to the market dynamics.  Or so the theory goes!
-    class DominantCycles
+    module DominantCycles
       class DominantCyclePoint < Quant::Indicators::IndicatorPoint
         attribute :smooth, default: 0.0
         attribute :detrend, default: 0.0
@@ -44,6 +42,15 @@ module Quant
       end
 
       class DominantCycle < Indicators::Indicator
+        def priority
+          DOMINANT_CYCLES_PRIORITY
+        end
+
+        # Dominant Cycle Indicators should not themselves have a dominant cycle indicator
+        def dominant_cycle_indicator_class
+          nil
+        end
+
         def points_class
           Object.const_get "Quant::Indicators::DominantCycles::#{indicator_name}Point"
         rescue NameError

data/lib/quant/indicators/dominant_cycles/half_period.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "dominant_cycle"
-
 module Quant
-  class Indicators
-    class DominantCycles
+  module Indicators
+    module DominantCycles
       # This dominant cycle indicator is based on the half period
       # that is the midpoint of the `min_period` and `max_period`
       # configured in the `Quant.config.indicators` object.

data/lib/quant/indicators/dominant_cycles/homodyne.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "../indicator_point"
-require_relative "dominant_cycle"
-
 module Quant
-  class Indicators
-    class DominantCycles
+  module Indicators
+    module DominantCycles
       # Homodyne means the signal is multiplied by itself. More precisely,
       # we want to multiply the signal of the current bar with the complex
       # value of the signal one bar ago

data/lib/quant/indicators/dominant_cycles/phase_accumulator.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "dominant_cycle"
-
 module Quant
-  class Indicators
-    class DominantCycles
+  module Indicators
+    module DominantCycles
       # The phase accumulation method of computing the dominant cycle is perhaps
       # the easiest to comprehend. In this technique, we measure the phase
       # at each sample by taking the arctangent of the ratio of the quadrature

data/lib/quant/indicators/frama.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     class FramaPoint < IndicatorPoint
       attribute :frama, default: :input
+      attribute :dimension, default: 0.0
+      attribute :alpha, default: 0.0
     end
 
     # FRAMA (FRactal Adaptive Moving Average). A nonlinear moving average
@@ -23,11 +25,6 @@ module Quant
         end
       end
 
-      # def max_period
-      #   mp = dc_period
-      #   mp.even? ? mp : mp + 1
-      # end
-
       def half_period
         max_period / 2
       end
@@ -44,9 +41,9 @@ module Quant
         ppn1 = pp.last(half_period)
         n1 = (ppn1.maximum - ppn1.minimum) / half_period
 
-        dimension = (Math.log(n1 + n2) - Math.log(n3)) / Math.log(2)
-        alpha = Math.exp(-4.6 * (dimension - 1.0)).clamp(0.01, 1.0)
-        p0.frama = (alpha * p0.input) + ((1 - alpha) * p1.frama)
+        p0.dimension = (Math.log(n1 + n2) - Math.log(n3)) / Math.log(2)
+        p0.alpha = Math.exp(-4.6 * (p0.dimension - 1.0)).clamp(0.01, 1.0)
+        p0.frama = (p0.alpha * p0.input) + ((1 - p0.alpha) * p1.frama)
       end
     end
   end

data/lib/quant/indicators/indicator.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
+    # The {Quant::Indicators::Indicator} class is the abstract ancestor for all Indicators.
+    #
     class Indicator
       include Enumerable
       include Mixins::Functions
@@ -13,16 +15,57 @@ module Quant
       include Mixins::FisherTransform
       # include Mixins::Direction
 
+      # Provides a registry of dependent indicators for each indicator class.
+      # NOTE: Internal use only.
+      def self.dependent_indicator_classes
+        @dependent_indicator_classes ||= Set.new
+      end
+
+      # Use the {depends_on} method to declare dependencies for an indicator.
+      # @param indicator_classes [Array<Class>] The classes of the indicators to depend on.
+      # @example
+      #   class BarIndicator < Indicator
+      #     depends_on FooIndicator
+      #   end
+      def self.depends_on(*indicator_classes)
+        Array(indicator_classes).each{ |dependency| dependent_indicator_classes << dependency }
+      end
+
       attr_reader :source, :series
 
       def initialize(series:, source:)
         @series = series
         @source = source
         @points = {}
-        series.new_indicator(self)
         series.each { |tick| self << tick }
       end
 
+      def dominant_cycle_indicator_class
+        Quant.config.indicators.dominant_cycle_indicator_class
+      end
+
+      # The priority drives the order of computations when iterating over each tick
+      # in a series.  Generally speaking, indicators that feed values to another indicator
+      # must have a lower priority value than the indicator that consumes the values.
+      #   * Most indicators will have a default priority of 1000.
+      #   * Dominant Cycle indicators will have a priority of 100.
+      #   * Some indicators will have a "high priority" of 500.
+      # Priority values are arbitrary and purposefully gapping so that new indicators
+      # introduced outside the core library can be slotted in between.
+      #
+      # NOTE: Priority is well-managed by the library and should not require overriding
+      # for a custom indicator developed outside the library.  If you find yourself
+      # needing to override this method, please open an issue on the library's GitHub page.
+      PRIORITIES = [
+        DOMINANT_CYCLES_PRIORITY = 100,
+        DEPENDENCY_PRIORITY = 500,
+        DEFAULT_PRIORITY = 1000
+      ].freeze
+
+      def priority
+        DEFAULT_PRIORITY
+      end
+
       def min_period
         Quant.config.indicators.min_period
       end
@@ -48,7 +91,7 @@ module Quant
       end
 
       def dominant_cycle
-        series.indicators[source].dominant_cycle
+        series.indicators[source][dominant_cycle_indicator_class]
       end
 
       def dc_period

data/lib/quant/indicators/indicator_point.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     class IndicatorPoint
       include Quant::Attributes
       extend Forwardable

data/lib/quant/indicators/mama.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     class MamaPoint < IndicatorPoint
       attribute :smooth, default: 0.0
       attribute :detrend, default: 0.0

data/lib/quant/indicators/mesa.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module Indicators
     # The MESA inidicator
     class MesaPoint < IndicatorPoint
       attribute :mama, default: :input

data/lib/quant/indicators/ping.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  class Indicators
+  module 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.

data/lib/quant/indicators/pivot.rb

@@ -0,0 +1,107 @@
+module Quant
+  module Indicators
+    class PivotPoint < IndicatorPoint
+      attribute :high_price
+      attribute :avg_high, default: :high_price
+      attribute :highest, default: :input
+
+      attribute :low_price
+      attribute :avg_low, default: :low_price
+      attribute :lowest, default: :input
+
+      attribute :range, default: 0.0
+      attribute :avg_range, default: 0.0
+      attribute :std_dev, default: 0.0
+
+      def bands
+        @bands ||= { 0 => input }
+      end
+
+      def [](band)
+        bands[band]
+      end
+
+      def []=(band, value)
+        bands[band] = value
+      end
+
+      def key?(band)
+        bands.key?(band)
+      end
+
+      def midpoint
+        bands[0]
+      end
+      alias :h0 :midpoint
+      alias :l0 :midpoint
+
+      def midpoint=(value)
+        bands[0] = value
+      end
+      alias :h0= :midpoint=
+      alias :l0= :midpoint=
+
+      (1..8).each do |band|
+        define_method("h#{band}") { bands[band] }
+        define_method("h#{band}=") { |value| bands[band] = value }
+
+        define_method("l#{band}") { bands[-band] }
+        define_method("l#{band}=") { |value| bands[-band] = value }
+      end
+    end
+
+    class Pivot < Indicator
+      def points_class
+        Quant::Indicators::PivotPoint
+      end
+
+      def band?(band)
+        p0.key?(band)
+      end
+
+      def period
+        dc_period
+      end
+
+      def averaging_period
+        min_period
+      end
+
+      def period_midpoints
+        period_points(period).map(&:midpoint)
+      end
+
+      def compute
+        compute_extents
+        compute_value
+        compute_midpoint
+        compute_bands
+      end
+
+      def compute_midpoint
+        p0.midpoint = p0.input
+      end
+
+      def compute_value
+        # No-op -- override in subclasses
+      end
+
+      def compute_bands
+        # No-op -- override in subclasses
+      end
+
+      def compute_extents
+        period_midpoints.tap do |midpoints|
+          p0.high_price = t0.high_price
+          p0.low_price = t0.low_price
+          p0.highest = midpoints.max
+          p0.lowest = midpoints.min
+          p0.range = p0.high_price - p0.low_price
+          p0.avg_low = super_smoother(:low_price, previous: :avg_low, period: averaging_period)
+          p0.avg_high = super_smoother(:high_price, previous: :avg_high, period: averaging_period)
+          p0.avg_range = super_smoother(:range, previous: :avg_range, period: averaging_period)
+        end
+      end
+    end
+  end
+end