quantitative 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf0aa73684247efc7bc9750c27c856a094fa362d99c1eba73bd70457da8f3a97
-  data.tar.gz: 56dcaa82230328cb44149ceb957420484217e33c6f601ea135997391bfb95440
+  metadata.gz: '06693d3511af25d58463fd872f004265889bb0c8d8344dd4fc8436bd4a66f63b'
+  data.tar.gz: b1e7db72820532999567608e1d3b864a7e4b1029b363de4c05c1032b177abc5a
 SHA512:
-  metadata.gz: b674a5e4408a69039cf2c7ad2378d065e3f88b409a7530108af1bfc5a186a02690cba8ffb1c8d40a87ad69368f302d9eec0211135beec7db6a9c51c4e1be46d3
-  data.tar.gz: e7d7693cd878ebe777f81ca0d90b4f305e645c8547aa9f420cccb4a4f9b53920211a2b7f49af146508756e6e38f5cc7e0c4b57f1c8abdd722f65bd3409abd02f
+  metadata.gz: 6dcc22eaa684535f9452287e1a486d2de3bc3d38b12be207130e62fb0264ea90087e20c9a9693952b8be3030738a3eebd8681813ccf2f0c2838aa9c33c9ad7b1
+  data.tar.gz: 05d9470a2c3426c46b6e64113b728672d841640dea56887d1efc9fcd9c7839b561f09cb2da4d6453bd339222bd07f48885bbae443e55646b90b855cd6bec716f

data/Gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in quantitative.gemspec
+# Specify your gem"s dependencies in quantitative.gemspec
 gemspec
 
 gem "rake", "~> 13.0"
@@ -18,7 +18,12 @@ gem "guard-rspec", "~> 4.7"
 gem "yard", "~> 0.9"
 gem "benchmark-ips", "~> 2.9"
 
-gem 'rspec-github'
-gem 'simplecov'
-gem 'simplecov-cobertura'
+gem "rspec-github"
 
+# Test coverage and profiling
+gem "simplecov"
+gem "simplecov-cobertura"
+gem "stackprof", require: false
+gem "test-prof", require: false
+gem "vernier", require: false
+gem "ruby-prof", require: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.2.1)
+    quantitative (0.3.0)
       oj (~> 3.10)
 
 GEM
@@ -107,6 +107,7 @@ GEM
       rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
+    ruby-prof (1.7.0)
     ruby-progressbar (1.13.0)
     shellany (0.0.1)
     simplecov (0.22.0)
@@ -118,9 +119,12 @@ GEM
       simplecov (~> 0.19)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    stackprof (0.2.26)
     stringio (3.1.0)
+    test-prof (1.3.2)
     thor (1.3.0)
     unicode-display_width (2.5.0)
+    vernier (0.5.1)
     yard (0.9.34)
 
 PLATFORMS
@@ -138,8 +142,12 @@ DEPENDENCIES
   rspec-github
   rubocop (~> 1.21)
   rubocop-rspec
+  ruby-prof
   simplecov
   simplecov-cobertura
+  stackprof
+  test-prof
+  vernier
   yard (~> 0.9)
 
 BUNDLED WITH

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/{indicators/dominant_cycle_indicators.rb → dominant_cycles_source.rb}

@@ -1,3 +1,4 @@
+
 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
@@ -13,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
@@ -25,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
@@ -37,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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "indicator_point"
+require_relative "indicator"
+require_relative "atr"
+
+module Quant
+  class Indicators
+    class AdxPoint < IndicatorPoint
+      attribute :dmu, default: 0.0
+      attribute :dmd, default: 0.0
+      attribute :dmu_ema, default: 0.0
+      attribute :dmd_ema, default: 0.0
+      attribute :diu, default: 0.0
+      attribute :did, default: 0.0
+      attribute :di, default: 0.0
+      attribute :di_ema, default: 0.0
+      attribute :value, default: 0.0
+      attribute :inst_stoch, default: 0.0
+      attribute :stoch, default: 0.0
+      attribute :stoch_up, default: false
+      attribute :stoch_turned, default: false
+      attribute :ssf, default: 0.0
+      attribute :hp, default: 0.0
+    end
+
+    class Adx < Indicator
+      depends_on Indicators::Atr
+
+      def alpha
+        bars_to_alpha(dc_period)
+      end
+
+      def scale
+        1.0
+      end
+
+      def period
+        dc_period
+      end
+
+      def atr_point
+        series.indicators[source].atr.points[t0]
+      end
+
+      def compute
+        # To calculate the ADX, first determine the + and - directional movement, or DM.
+        # The +DM and -DM are found by calculating the "up-move," or current high minus
+        # the previous high, and "down-move," or current low minus the previous low.
+        # If the up-move is greater than the down-move and greater than zero, the +DM equals the up-move;
+        # otherwise, it equals zero. If the down-move is greater than the up-move and greater than zero,
+        # the -DM equals the down-move; otherwise, it equals zero.
+        dm_highs = [t0.high_price - t1.high_price, 0.0].max
+        dm_lows  = [t0.low_price - t1.low_price, 0.0].max
+
+        p0.dmu = dm_highs > dm_lows ? 0.0 : dm_highs
+        p0.dmd = dm_lows > dm_highs ? 0.0 : dm_lows
+
+        p0.dmu_ema = three_pole_super_smooth :dmu, period:, previous: :dmu_ema
+        p0.dmd_ema = three_pole_super_smooth :dmd, period:, previous: :dmd_ema
+
+        atr_value = atr_point.fast * scale
+        return if atr_value == 0.0 || @points.size < period
+
+        # The positive directional indicator, or +DI, equals 100 times the EMA of +DM divided by the ATR
+        # over a given number of time periods. Welles usually used 14 periods.
+        # The negative directional indicator, or -DI, equals 100 times the EMA of -DM divided by the ATR.
+        p0.diu = (100.0 * p0.dmu_ema) / atr_value
+        p0.did = (100.0 * p0.dmd_ema) / atr_value
+
+        # The ADX indicator itself equals 100 times the EMA of the absolute value of (+DI minus -DI)
+        # divided by (+DI plus -DI).
+        delta = p0.diu + p0.did
+        p0.di = (p0.diu - p1.did).abs / delta
+        p0.di_ema = three_pole_super_smooth(:di, period:, previous: :di_ema).clamp(-10.0, 10.0)
+
+        p0.value = p0.di_ema
+        p0.inst_stoch = stochastic :di, period: dc_period
+        p0.stoch = three_pole_super_smooth :inst_stoch, period:, previous: :stoch
+      end
+    end
+  end
+end

data/lib/quant/indicators/atr.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "indicator_point"
+require_relative "indicator"
+
+module Quant
+  class Indicators
+    class AtrPoint < IndicatorPoint
+      attribute :tr, default: 0.0
+      attribute :period, default: :min_period
+      attribute :value, default: 0.0
+      attribute :slow, default: 0.0
+      attribute :fast, default: 0.0
+      attribute :inst_stoch, default: 0.0
+      attribute :stoch, default: 0.0
+      attribute :stoch_up, default: false
+      attribute :stoch_turned, default: false
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    class Atr < Indicator
+      attr_reader :points
+
+      def period
+        dc_period / 2
+      end
+
+      def fast_alpha
+        period_to_alpha(period)
+      end
+
+      def slow_alpha
+        period_to_alpha(2 * period)
+      end
+
+      # Typically, the Average True Range (ATR) is based on 14 periods and can be calculated on an intraday, daily, weekly
+      # or monthly basis. For this example, the ATR will be based on daily data. Because there must be a beginning, the first
+      # TR value is simply the High minus the Low, and the first 14-day ATR is the average of the daily TR values for the
+      # last 14 days. After that, Wilder sought to smooth the data by incorporating the previous period's ATR value.
+
+      # Current ATR = [(Prior ATR x 13) + Current TR] / 14
+
+      #   - Multiply the previous 14-day ATR by 13.
+      #   - Add the most recent day's TR value.
+      #   - Divide the total by 14
+
+      def compute
+        p0.period = period
+        p0.tr = (t1.high_price - t0.close_price).abs
+
+        p0.value = three_pole_super_smooth :tr, period:, previous: :value
+
+        p0.slow = (slow_alpha * p0.value) + ((1.0 - slow_alpha) * p1.slow)
+        p0.fast = (fast_alpha * p0.value) + ((1.0 - fast_alpha) * p1.fast)
+
+        p0.inst_stoch = stochastic :value, period:
+        p0.stoch = three_pole_super_smooth(:inst_stoch, previous: :stoch, period:).clamp(0, 100)
+        p0.stoch_up = p0.stoch >= 70
+        p0.stoch_turned = p0.stoch_up && !p1.stoch_up
+        compute_oscillator
+      end
+
+      def compute_oscillator
+        p0.osc = p0.value - wma(:value)
+        p0.crossed = :up if p0.osc >= 0 && p1.osc < 0
+        p0.crossed = :down if p0.osc <= 0 && p1.osc > 0
+      end
+    end
+  end
+end

data/lib/quant/indicators/cci.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class CciPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :real, default: 0.0
+      attribute :imag, default: 0.0
+      attribute :angle, default: 0.0
+      attribute :state, default: 0
+    end
+
+    # Correlation Cycle Index
+    # The very definition of a trend mode and a cycle mode makes it simple
+    # to create a state variable that identifies the market state. If the
+    # state is zero, the market is in a cycle mode. If the state is +1 the
+    # market is in a trend up. If the state is -1 the market is in a trend down.
+    #
+    # SOURCE: https://www.mesasoftware.com/papers/CORRELATION%20AS%20A%20CYCLE%20INDICATOR.pdf
+    class Cci < Indicator
+      def max_period
+        [min_period, dc_period].max
+      end
+
+      def compute_correlations
+        corr_real = Statistics::Correlation.new
+        corr_imag = Statistics::Correlation.new
+        arc = 2.0 * Math::PI / max_period.to_f
+        (0...max_period).each do |period|
+          radians = arc * period
+          prev_hp = p(period).hp
+          corr_real.add(prev_hp, Math.cos(radians))
+          corr_imag.add(prev_hp, -Math.sin(radians))
+        end
+        p0.real = corr_real.coefficient
+        p0.imag = corr_imag.coefficient
+      end
+
+      def compute_angle
+        # Compute the angle as an arctangent and resolve the quadrant
+        p0.angle = 90 + rad2deg(Math.atan(p0.real / p0.imag))
+        p0.angle -= 180 if p0.imag > 0
+
+        # Do not allow the rate change of angle to go negative
+        p0.angle = p1.angle if (p0.angle < p1.angle) && (p1.angle - p0.angle) < 270
+      end
+
+      def compute_state
+        return unless (p0.angle - p1.angle).abs < 9
+
+        p0.state = p0.angle < 0 ? -1 : 1
+      end
+
+      def compute
+        p0.hp = two_pole_butterworth :input, previous: :hp, period: min_period
+
+        compute_correlations
+        compute_angle
+        compute_state
+      end
+    end
+  end
+end

data/lib/quant/indicators/decycler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Quant
+  class 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.
+    #
+    # 1. A decycler filter functions the same as a low-pass filter.
+    # 2. A decycler filter is created by subtracting the output of a high-pass filter from the input, thereby removing the
+    #    high-frequency components by cancellation.
+    # 3. A decycler filter has very low lag.
+    # 4. A decycler oscillator is created by subtracting the output of a high-pass filter having a shorter cutoff period from the
+    #    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
+      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
+      def max_period
+        dc_period
+      end
+
+      def compute_decycler
+        alpha = period_to_alpha(max_period)
+        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);
+      # HP1 = (1 - alpha1 / 2)*(1 - alpha1 / 2)*(Close - 2*Close[1] + Close[2]) + 2*(1 - alpha1)*HP1[1] - (1 - alpha1)*(1 - alpha1)*HP1[2];
+      def compute_hp(period, hp)
+        radians = deg2rad(360)
+        c = Math.cos(0.707 * radians / period)
+        s = Math.sin(0.707 * radians / period)
+        alpha = (c + s - 1) / c
+        (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
+        p0.hp1 = compute_hp(min_period, :hp1)
+        p0.hp2 = compute_hp(max_period, :hp2)
+        p0.osc = p0.hp2 - p0.hp1
+      end
+
+      # 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_inverse_fisher_transform
+        p0.ift = inverse_fisher_transform(p0.agc, scale_factor: 5.0)
+      end
+
+      def compute
+        compute_decycler
+        compute_oscillator
+        compute_automatic_gain_control
+        compute_inverse_fisher_transform
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator_point"
 require_relative "dominant_cycle"
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
     class DominantCycles
@@ -18,4 +20,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator"
 
 module Quant
@@ -42,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
@@ -76,11 +87,6 @@ module Quant
           [p0.period.to_i, min_period].max
         end
 
-        def period_points(max_period)
-          extent = [values.size, max_period].min
-          values[-extent, extent]
-        end
-
         def compute
           compute_input_data_points
           compute_quadrature_components
@@ -141,4 +147,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../indicator_point"
 require_relative "dominant_cycle"
 
@@ -15,7 +17,7 @@ module Quant
           p0.re = (0.2 * p0.re) + (0.8 * p1.re)
           p0.im = (0.2 * p0.im) + (0.8 * p1.im)
 
-          p0.inst_period = 360.0 / rad2deg(Math.atan(p0.im/p0.re)) if (p0.im != 0) && (p0.re != 0)
+          p0.inst_period = 360.0 / rad2deg(Math.atan(p0.im / p0.re)) if (p0.im != 0) && (p0.re != 0)
 
           constrain_period_magnitude_change
           constrain_period_bars
@@ -25,4 +27,4 @@ module Quant
       end
     end
   end
-end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "dominant_cycle"
 
 module Quant
@@ -30,10 +32,12 @@ module Quant
 
           p0.accumulator_phase = Math.atan(p0.q1 / p0.i1) unless p0.i1.zero?
 
-          case
-          when p0.i1 < 0 && p0.q1 > 0 then p0.accumulator_phase = 180.0 - p0.accumulator_phase
-          when p0.i1 < 0 && p0.q1 < 0 then p0.accumulator_phase = 180.0 + p0.accumulator_phase
-          when p0.i1 > 0 && p0.q1 < 0 then p0.accumulator_phase = 360.0 - p0.accumulator_phase
+          if p0.i1 < 0 && p0.q1 > 0
+            p0.accumulator_phase = 180.0 - p0.accumulator_phase
+          elsif p0.i1 < 0 && p0.q1 < 0
+            p0.accumulator_phase = 180.0 + p0.accumulator_phase
+          elsif p0.i1 > 0 && p0.q1 < 0
+            p0.accumulator_phase = 360.0 - p0.accumulator_phase
           end
 
           p0.delta_phase = p1.accumulator_phase - p0.accumulator_phase

data/lib/quant/indicators/frama.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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
+    # is derived using the Hurst exponent. It rapidly follows significant
+    # changes in price but becomes very flat in congestion zones so that
+    # bad whipsaw trades can be eliminated.
+    #
+    # SOURCE: http://www.mesasoftware.com/papers/FRAMA.pdf
+    class Frama < Indicator
+      using Quant
+
+      # The max_period is divided into two smaller, equal periods, so must be even
+      def max_period
+        @max_period ||= begin
+          mp = super
+          mp.even? ? mp : mp + 1
+        end
+      end
+
+      def half_period
+        max_period / 2
+      end
+
+      def compute
+        pp = period_points(max_period).map(&:input)
+        return if pp.size < max_period
+
+        n3 = (pp.maximum - pp.minimum) / max_period
+
+        ppn2 = pp.first(half_period)
+        n2 = (ppn2.maximum - ppn2.minimum) / half_period
+
+        ppn1 = pp.last(half_period)
+        n1 = (ppn1.maximum - ppn1.minimum) / half_period
+
+        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
+end