quantitative 0.2.1 → 0.3.0

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
@@ -71,6 +114,11 @@ module Quant
         @points.size
       end
 
+      def period_points(max_period)
+        extent = [values.size, max_period].min
+        values[-extent, extent]
+      end
+
       attr_reader :p0, :p1, :p2, :p3
       attr_reader :t0, :t1, :t2, :t3
 

data/lib/quant/indicators/mama.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class MamaPoint < IndicatorPoint
+      attribute :smooth, default: 0.0
+      attribute :detrend, default: 0.0
+      attribute :re, default: 0.0
+      attribute :im, default: 0.0
+      attribute :i1, default: 0.0
+      attribute :q1, default: 0.0
+      attribute :ji, default: 0.0
+      attribute :jq, default: 0.0
+      attribute :i2, default: 0.0
+      attribute :q2, default: 0.0
+      attribute :period, default: :min_period
+      attribute :smooth_period, default: :min_period
+      attribute :mama, default: :input
+      attribute :fama, default: :input
+      attribute :gama, default: :input
+      attribute :dama, default: :input
+      attribute :lama, default: :input
+      attribute :faga, default: :input
+      attribute :phase, default: 0.0
+      attribute :delta_phase, default: 0.0
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    # https://www.mesasoftware.com/papers/MAMA.pdf
+    # MESA Adaptive Moving Average (MAMA) adapts to price movement in an
+    # entirely new and unique way. The adapation is based on the rate change
+    # of phase as measured by the Hilbert Transform Discriminator.
+    #
+    # This version of Ehler's MAMA indicator duplicates the computations
+    # present in the homodyne version of the dominant cycle indicator.
+    # Use this version of the indicator when you're using a different
+    # dominant cycle indicator other than the homodyne for the rest
+    # of your indicators.
+    class Mama < Indicator
+      # constrain between 6 and 50 bars
+      def constrain_period_bars
+        p0.period = p0.period.clamp(min_period, max_period)
+      end
+
+      # constrain magnitude of change in phase
+      def constrain_period_magnitude_change
+        p0.period = [1.5 * p1.period, p0.period].min
+        p0.period = [0.67 * p1.period, p0.period].max
+      end
+
+      # amplitude correction using previous period value
+      def compute_smooth_period
+        p0.period = ((0.2 * p0.period) + (0.8 * p1.period)).round
+        p0.smooth_period = ((0.33333 * p0.period) + (0.666667 * p1.smooth_period)).round
+      end
+
+      def homodyne_discriminator
+        p0.re = (p0.i2 * p1.i2) + (p0.q2 * p1.q2)
+        p0.im = (p0.i2 * p1.q2) - (p0.q2 * p1.i2)
+
+        p0.re = (0.2 * p0.re) + (0.8 * p1.re)
+        p0.im = (0.2 * p0.im) + (0.8 * p1.im)
+
+        p0.period = 360.0 / rad2deg(Math.atan(p0.im / p0.re)) if (p0.im != 0) && (p0.re != 0)
+
+        constrain_period_magnitude_change
+        constrain_period_bars
+        compute_smooth_period
+      end
+
+      def compute_dominant_cycle
+        p0.smooth = wma :input
+        p0.detrend = hilbert_transform :smooth, period: p1.period
+
+        # { Compute Inphase and Quadrature components }
+        p0.q1 = hilbert_transform :detrend, period: p1.period
+        p0.i1 = p3.detrend
+
+        # { Advance the phase of I1 and Q1 by 90 degrees }
+        p0.ji = hilbert_transform :i1, period: p1.period
+        p0.jq = hilbert_transform :q1, period: p1.period
+
+        # { Smooth the I and Q components before applying the discriminator }
+        p0.i2 = (0.2 * (p0.i1 - p0.jq)) + 0.8 * (p1.i2 || (p0.i1 - p0.jq))
+        p0.q2 = (0.2 * (p0.q1 + p0.ji)) + 0.8 * (p1.q2 || (p0.q1 + p0.ji))
+
+        homodyne_discriminator
+      end
+
+      def fast_limit
+        @fast_limit ||= bars_to_alpha(min_period / 2)
+      end
+
+      def slow_limit
+        @slow_limit ||= bars_to_alpha(max_period)
+      end
+
+      def compute_dominant_cycle_phase
+        p0.delta_phase = p1.phase - p0.phase
+        p0.delta_phase = 1.0 if p0.delta_phase < 1.0
+      end
+
+      FAMA = 0.500
+      GAMA = 0.950
+      DAMA = 0.125
+      LAMA = 0.100
+      FAGA = 0.050
+
+      def compute_moving_averages
+        alpha = [fast_limit / p0.delta_phase, slow_limit].max
+        p0.mama = (alpha * p0.input) + ((1.0 - alpha) * p1.mama)
+
+        p0.fama = (FAMA * alpha * p0.mama) + ((1.0 - (FAMA * alpha)) * p1.fama)
+        p0.gama = (GAMA * alpha * p0.mama) + ((1.0 - (GAMA * alpha)) * p1.gama)
+        p0.dama = (DAMA * alpha * p0.mama) + ((1.0 - (DAMA * alpha)) * p1.dama)
+        p0.lama = (LAMA * alpha * p0.mama) + ((1.0 - (LAMA * alpha)) * p1.lama)
+        p0.faga = (FAGA * alpha * p0.fama) + ((1.0 - (FAGA * alpha)) * p1.faga)
+      end
+
+      def compute_oscillator
+        p0.osc = p0.mama - p0.fama
+        p0.crossed = :up if p0.osc >= 0 && p1.osc < 0
+        p0.crossed = :down if p0.osc <= 0 && p1.osc > 0
+      end
+
+      def compute
+        compute_dominant_cycle
+        compute_dominant_cycle_phase
+        compute_moving_averages
+        compute_oscillator
+      end
+    end
+  end
+end

data/lib/quant/indicators/mesa.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    # The MESA inidicator
+    class MesaPoint < IndicatorPoint
+      attribute :mama, default: :input
+      attribute :fama, default: :input
+      attribute :dama, default: :input
+      attribute :gama, default: :input
+      attribute :lama, default: :input
+      attribute :faga, default: :input
+      attribute :osc, default: 0.0
+      attribute :crossed, default: :unchanged
+
+      def crossed_up?
+        @crossed == :up
+      end
+
+      def crossed_down?
+        @crossed == :down
+      end
+    end
+
+    # https://www.mesasoftware.com/papers/MAMA.pdf
+    # MESA Adaptive Moving Average (MAMA) adapts to price movement in an
+    # entirely new and unique way. The adapation is based on the rate change
+    # of phase as measured by the Hilbert Transform Discriminator.
+    #
+    # This version of Ehler's MAMA indicator ties into the homodyne
+    # dominant cycle indicator to provide a more efficient computation
+    # for this indicator.  If you're using the homodyne in all your
+    # indicators for the dominant cycle, then this version is useful
+    # as it avoids extra computational steps.
+    class Mesa < Indicator
+      def period
+        dc_period
+      end
+
+      def fast_limit
+        @fast_limit ||= bars_to_alpha(min_period / 2)
+      end
+
+      def slow_limit
+        @slow_limit ||= bars_to_alpha(max_period)
+      end
+
+      def homodyne_dominant_cycle
+        series.indicators[source].dominant_cycles.homodyne
+      end
+
+      def current_dominant_cycle
+        homodyne_dominant_cycle.points[t0]
+      end
+
+      def delta_phase
+        current_dominant_cycle.delta_phase
+      end
+
+      FAMA = 0.500
+      GAMA = 0.950
+      DAMA = 0.125
+      LAMA = 0.100
+      FAGA = 0.050
+
+      def compute
+        alpha = [fast_limit / delta_phase, slow_limit].max
+
+        p0.mama = (alpha * p0.input) + ((1.0 - alpha) * p1.mama)
+        p0.fama = (FAMA * alpha * p0.mama) + ((1.0 - (FAMA * alpha)) * p1.fama)
+        p0.gama = (GAMA * alpha * p0.mama) + ((1.0 - (GAMA * alpha)) * p1.gama)
+        p0.dama = (DAMA * alpha * p0.mama) + ((1.0 - (DAMA * alpha)) * p1.dama)
+        p0.lama = (LAMA * alpha * p0.mama) + ((1.0 - (LAMA * alpha)) * p1.lama)
+        p0.faga = (FAGA * alpha * p0.fama) + ((1.0 - (FAGA * alpha)) * p1.faga)
+
+        compute_oscillator
+      end
+
+      def compute_oscillator
+        p0.osc = p0.mama - p0.fama
+        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/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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class Pivots
+      class Donchian < Pivot
+        using Quant
+
+        def st_period; min_period end
+        def mt_period; half_period end
+        def lt_period; max_period end
+
+        def st_highs; @st_highs ||= [].max_size!(st_period) end
+        def st_lows; @st_lows ||= [].max_size!(st_period) end
+        def mt_highs; @mt_highs ||= [].max_size!(mt_period) end
+        def mt_lows; @mt_lows ||= [].max_size!(mt_period) end
+        def lt_highs; @lt_highs ||= [].max_size!(lt_period) end
+        def lt_lows; @lt_lows ||= [].max_size!(lt_period) end
+
+        def compute_bands
+          st_highs << p0.high_price
+          st_lows << p0.low_price
+          mt_highs << p0.high_price
+          mt_lows << p0.low_price
+          lt_highs << p0.high_price
+          lt_lows << p0.low_price
+
+          p0.h1 = @st_highs.maximum
+          p0.l1 = @st_lows.minimum
+
+          p0.h2 = @mt_highs.maximum
+          p0.l2 = @mt_lows.minimum
+
+          p0.h3 = @lt_highs.maximum
+          p0.l3 = @lt_lows.minimum
+        end
+      end
+    end
+  end
+end