quantitative 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5786b75635cde82e7919fce6b8fcd568724b27fc2810efe6db36a7e6dd09cc
-  data.tar.gz: 3a6fb86c25bb4f2b1e4994710539bfb528377ef57531e6845a4417c87fc86e29
+  metadata.gz: '06693d3511af25d58463fd872f004265889bb0c8d8344dd4fc8436bd4a66f63b'
+  data.tar.gz: b1e7db72820532999567608e1d3b864a7e4b1029b363de4c05c1032b177abc5a
 SHA512:
-  metadata.gz: 5ae30c5b971d6c7bd41e3c2b764e7d95438931790271133dc0e3a476a371affddfdcf06355ffa933240c0c9952fd8fa5e4212c496c95c80f028de7399d3b129f
-  data.tar.gz: 9ff8aeaf24800a7208e51f836dd7c7c3621b2e2e3a7f1e8820d89f6fc5cd56dd3c4b762c478d221c6ef7279f62c0df75ae1a19f6a4d34e7ba82e116e6a10a790
+  metadata.gz: 6dcc22eaa684535f9452287e1a486d2de3bc3d38b12be207130e62fb0264ea90087e20c9a9693952b8be3030738a3eebd8681813ccf2f0c2838aa9c33c9ad7b1
+  data.tar.gz: 05d9470a2c3426c46b6e64113b728672d841640dea56887d1efc9fcd9c7839b561f09cb2da4d6453bd339222bd07f48885bbae443e55646b90b855cd6bec716f

data/Gemfile.lock

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

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/{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,21 @@
 # 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)
+    return if Experimental.rspec_defined?
     return if Experimental.tracker[caller.first]
 
     Experimental.tracker[caller.first] = message

data/lib/quant/indicators/adx.rb

@@ -2,6 +2,7 @@
 
 require_relative "indicator_point"
 require_relative "indicator"
+require_relative "atr"
 
 module Quant
   class Indicators
@@ -24,6 +25,8 @@ module Quant
     end
 
     class Adx < Indicator
+      depends_on Indicators::Atr
+
       def alpha
         bars_to_alpha(dc_period)
       end

data/lib/quant/indicators/decycler.rb

@@ -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/dominant_cycle.rb

@@ -44,6 +44,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/frama.rb

@@ -4,6 +4,8 @@ module Quant
   class 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

@@ -2,6 +2,8 @@
 
 module Quant
   class 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/pivot.rb

@@ -0,0 +1,107 @@
+module Quant
+  class 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

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

@@ -0,0 +1,41 @@
+module Quant
+  class Indicators
+    class Pivots
+      class Atr < Pivot
+        depends_on Indicators::Atr
+
+        def atr_point
+          series.indicators[source].atr.points[t0]
+        end
+
+        def scale
+          5.0
+        end
+
+        def atr_value
+          atr_point.slow * scale
+        end
+
+        def compute_midpoint
+          p0.midpoint = two_pole_super_smooth :input, previous: :midpoint, period: averaging_period
+        end
+
+        def compute_bands
+          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/bollinger.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class Pivots
+      class Bollinger < Pivot
+        using Quant
+
+        def compute_midpoint
+          values = period_points(half_period).map(&:input)
+          alpha = bars_to_alpha(half_period)
+
+          p0.midpoint = alpha * values.mean + (1 - alpha) * p1.midpoint
+          p0.std_dev = values.standard_deviation(p0.midpoint)
+        end
+
+        def compute_bands
+          p0.h1 = p0.midpoint + p0.std_dev * 1.0
+          p0.l1 = p0.midpoint - p0.std_dev * 1.0
+
+          p0.h2 = p0.midpoint + p0.std_dev * 1.5
+          p0.l2 = p0.midpoint - p0.std_dev * 1.5
+
+          p0.h3 = p0.midpoint + p0.std_dev * 1.75
+          p0.l3 = p0.midpoint - p0.std_dev * 1.75
+
+          p0.h4 = p0.midpoint + p0.std_dev * 2.0
+          p0.l4 = p0.midpoint - p0.std_dev * 2.0
+
+          p0.h5 = p0.midpoint + p0.std_dev * 2.25
+          p0.l5 = p0.midpoint - p0.std_dev * 2.25
+
+          p0.h6 = p0.midpoint + p0.std_dev * 2.5
+          p0.l6 = p0.midpoint - p0.std_dev * 2.5
+
+          p0.h7 = p0.midpoint + p0.std_dev * 2.75
+          p0.l7 = p0.midpoint - p0.std_dev * 2.75
+
+          p0.h8 = p0.midpoint + p0.std_dev * 3.0
+          p0.l8 = p0.midpoint - p0.std_dev * 3.0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class Pivots
+      # Camarilla pivot point calculations are rather straightforward. We need to
+      # input the previous day’s open, high, low and close. The formulas for each
+      # resistance and support level are:
+      #
+      # R4 = Close + (High – Low) * 1.1/2
+      # R3 = Close + (High – Low) * 1.1/4
+      # R2 = Close + (High – Low) * 1.1/6
+      # R1 = Close + (High – Low) * 1.1/12
+      # S1 = Close – (High – Low) * 1.1/12
+      # S2 = Close – (High – Low) * 1.1/6
+      # S3 = Close – (High – Low) * 1.1/4
+      # S4 = Close – (High – Low) * 1.1/2
+      #
+      # The calculation for further resistance and support levels varies from this
+      # norm. These levels can come into play during strong trend moves, so it’s
+      # important to understand how to identify them. For example, R5, R6, S5 and S6
+      # are calculated as follows:
+      #
+      # R5 = R4 + 1.168 * (R4 – R3)
+      # R6 = (High/Low) * Close
+      #
+      # S5 = S4 – 1.168 * (S3 – S4)
+      # S6 = Close – (R6 – Close)
+      class Camarilla < Pivot
+        def multiplier
+          1.1
+        end
+
+        def compute_midpoint
+          p0.midpoint = t0.close_price
+        end
+
+        def compute_bands
+          mp_plus_range = p0.midpoint + p0.range
+          mp_minus_range = p0.midpoint - p0.range
+
+          p0.h4 = mp_plus_range * (1.1 / 2.0)
+          p0.h3 = mp_plus_range * (1.1 / 4.0)
+          p0.h2 = mp_plus_range * (1.1 / 6.0)
+          p0.h1 = mp_plus_range * (1.1 / 12.0)
+
+          p0.l1 = mp_minus_range * (1.1 / 12.0)
+          p0.l2 = mp_minus_range * (1.1 / 6.0)
+          p0.l3 = mp_minus_range * (1.1 / 4.0)
+          p0.l4 = mp_minus_range * (1.1 / 2.0)
+
+          p0.h5 = p0.h4 + 1.168 * (p0.h4 - p0.h3)
+          p0.h6 = p0.midpoint * (p0.high_price / p0.low_price)
+
+          p0.l5 = p0.l4 - 1.168 * (p0.l3 - p0.l4)
+          p0.l6 = p0.midpoint - (p0.h6 - p0.midpoint)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class Pivots
+      class Classic < Pivot
+        def compute_midpoint
+          p0.midpoint = super_smoother :input, previous: :midpoint, period: averaging_period
+        end
+
+        def compute_bands
+          p0.h1 = p0.midpoint * 2.0 - p0.avg_low
+          p0.l1 = p0.midpoint * 2.0 - p0.avg_high
+
+          p0.h2 = p0.midpoint + p0.avg_range
+          p0.l2 = p0.midpoint - p0.avg_range
+
+          p0.h3 = p0.midpoint + 2.0 * p0.avg_range
+          p0.l3 = p0.midpoint - 2.0 * p0.avg_range
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class Pivots
+      # The value of X in the formula below depends on where the Close of the market is.
+      # If Close = Open then X = (H + L + (C * 2))
+
+      # If Close > Open then X = ((H * 2) + L + C)
+
+      # If Close < Open then X = (H + (L * 2) + C)
+
+      # R1 = X / 2 - L
+      # PP = X / 4 (this is not an official DeMark number but merely a reference point based on the calculation of X)
+      # S1 = X / 2 - H
+      class Demark < Pivot
+        def averaging_period
+          min_period / 2
+        end
+
+        def x_factor
+          if t0.close_price == t0.open_price
+            ((2.0 * t0.close_price) + p0.avg_high + p0.avg_low)
+          elsif t0.close_price > t0.open_price
+            ((2.0 * p0.avg_high) + p0.avg_low + t0.close_price)
+          else
+            ((2.0 * p0.avg_low) + p0.avg_high + t0.close_price)
+          end
+        end
+
+        def compute_value
+          p0.input = x_factor
+        end
+
+        def compute_midpoint
+          p0.midpoint = p0.input / 4.0
+          p0.midpoint = super_smoother :midpoint, previous: :midpoint, period: averaging_period
+        end
+
+        def compute_bands
+          p0.h1 = (p0.input / 2.0) - p0.avg_high
+          p0.h1 = super_smoother :h1, previous: :h1, period: averaging_period
+
+          p0.l1 = (p0.input / 2.0) - p0.avg_low
+          p0.l1 = super_smoother :l1, previous: :l1, period: averaging_period
+        end
+      end
+    end
+  end
+end