quantitative 0.2.2 → 0.3.1

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

@@ -0,0 +1,41 @@
+module Quant
+  module Indicators
+    module 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
+  module Indicators
+    module 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
+  module Indicators
+    module 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
+  module Indicators
+    module 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
+  module Indicators
+    module 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
+  module Indicators
+    module 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

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

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

@@ -1,18 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "indicators_proxy"
 module Quant
-  # TODO: build an Indicator registry so new indicators can be added and
-  #       used outside those shipped with the library.
-  class Indicators < IndicatorsProxy
-    def ping; indicator(Indicators::Ping) end
-    def adx; indicator(Indicators::Adx) end
-    def atr; indicator(Indicators::Atr) end
-    def mesa; indicator(Indicators::Mesa) end
-    def mama; indicator(Indicators::MAMA) end
-
-    def dominant_cycles
-      @dominant_cycles ||= Quant::DominantCycleIndicators.new(series:, source:)
-    end
+  module Indicators
   end
 end

data/lib/quant/indicators_source.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+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