quantitative 0.3.1 → 0.3.3

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

@@ -4,35 +4,32 @@ module Quant
   module Indicators
     module Pivots
       class Donchian < Pivot
-        using Quant
+        register name: :donchian
 
-        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_midpoint
+          p0.midpoint = (p0.high_price + p0.low_price) * 0.5
+        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
+          period_points(micro_period).tap do |period_points|
+            p0.l1 = period_points.map(&:low_price).min
+            p0.h1 = period_points.map(&:high_price).max
+          end
 
-          p0.h1 = @st_highs.maximum
-          p0.l1 = @st_lows.minimum
+          period_points(min_period).tap do |period_points|
+            p0.l2 = period_points.map(&:low_price).min
+            p0.h2 = period_points.map(&:high_price).max
+          end
 
-          p0.h2 = @mt_highs.maximum
-          p0.l2 = @mt_lows.minimum
+          period_points(half_period).tap do |period_points|
+            p0.l3 = period_points.map(&:low_price).min
+            p0.h3 = period_points.map(&:high_price).max
+          end
 
-          p0.h3 = @lt_highs.maximum
-          p0.l3 = @lt_lows.minimum
+          period_points(max_period).tap do |period_points|
+            p0.l4 = period_points.map(&:low_price).min
+            p0.h4 = period_points.map(&:high_price).max
+          end
         end
       end
     end

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

@@ -2,18 +2,21 @@ module Quant
   module Indicators
     module Pivots
       class Fibbonacci < Pivot
-        def averaging_period
-          half_period
-        end
+        register name: :fibbonacci
 
-        def fibbonacci_series
-          [0.146, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0, 1.146]
-        end
+        FIBBONACCI_SERIES = [0.146, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0, 1.146].freeze
 
         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
+          period_points(adaptive_period).tap do |period_points|
+            highest = period_points.map(&:high_price).max
+            lowest = period_points.map(&:low_price).min
+            p0.range = highest - lowest
+            p0.midpoint = (highest + lowest) * 0.5
+          end
+
+          FIBBONACCI_SERIES.each_with_index do |ratio, index|
+            p0[index + 1] = p0.midpoint + ratio * p0.range
+            p0[-index - 1] = p0.midpoint - ratio * p0.range
           end
         end
       end

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

@@ -2,6 +2,8 @@ module Quant
   module Indicators
     module Pivots
       class Guppy < Pivot
+        register name: :guppy
+
         def guppy_ema(period, band)
           return p0.input unless p1[band]
 
@@ -15,7 +17,7 @@ module Quant
 
         # 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
+        def compute_bands
           p0[1] = guppy_ema(5,  1)
           p0[2] = guppy_ema(8,  2)
           p0[3] = guppy_ema(10, 3)

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

@@ -2,6 +2,7 @@ module Quant
   module Indicators
     module Pivots
       class Keltner < Pivot
+        register name: :keltner
         depends_on Indicators::Atr
 
         def atr_point
@@ -9,33 +10,24 @@ module Quant
         end
 
         def scale
-          5.0
-        end
-
-        def alpha
-          bars_to_alpha(min_period)
+          3.0
         end
 
         def compute_midpoint
+          alpha = bars_to_alpha(min_period)
           p0.midpoint = alpha * p0.input + (1 - alpha) * p1.midpoint
         end
 
-        def compute_bands
-          atr_value = atr_point.slow * scale
+        KELTNER_SERIES = [0.236, 0.382, 0.500, 0.618, 0.786, 1.0].freeze
 
-          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
+        def compute_bands
+          atr_value = atr_point.value * scale
 
-          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
+          KELTNER_SERIES.each_with_index do |ratio, index|
+            offset = ratio * atr_value
+            p0[index + 1] = p0.midpoint + offset
+            p0[-index - 1] = p0.midpoint - offset
+          end
         end
       end
     end

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

@@ -3,6 +3,8 @@ module Quant
   module Indicators
     module Pivots
       class Murrey < Pivot
+        register name: :murrey
+
         def multiplier
           0.125
         end
@@ -12,20 +14,13 @@ module Quant
           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
+        MURREY_SERIES = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0].freeze
 
-          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
+        def compute_bands
+          MURREY_SERIES.each_with_index do |ratio, index|
+            p0[index + 1] = p0.midpoint + p0.input * ratio
+            p0[-index - 1] = p0.midpoint - p0.input * ratio
+          end
         end
       end
     end

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

@@ -0,0 +1,109 @@
+module Quant
+  module Indicators
+    module Pivots
+      class PivotPoint < IndicatorPoint
+        attribute :avg_high, default: :high_price
+        attribute :highest, default: :input
+
+        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::Pivots::PivotPoint
+        end
+
+        def band?(band)
+          p0.key?(band)
+        end
+
+        def period
+          adaptive_period
+        end
+
+        def averaging_period
+          min_period
+        end
+
+        def period_midpoints
+          period_points(period).map(&:midpoint)
+        end
+
+        def smoothed_average_midpoint
+          three_pole_super_smooth :input, previous: :midpoint, period: averaging_period
+        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.highest = midpoints.max
+            p0.lowest = midpoints.min
+            p0.range = p0.high_price - p0.low_price
+            p0.avg_low = three_pole_super_smooth(:low_price, previous: :avg_low, period: averaging_period)
+            p0.avg_high = three_pole_super_smooth(:high_price, previous: :avg_high, period: averaging_period)
+            p0.avg_range = three_pole_super_smooth(:range, previous: :avg_range, period: averaging_period)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@ module Quant
   module Indicators
     module Pivots
       class Traditional < Pivot
+        register name: :traditional
+
         def multiplier
           2.0
         end

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

@@ -22,6 +22,8 @@ module Quant
       #   S3 = L - 2 * (H - PP) (same as: S1 - RANGE)
       #   S4 = S3 - RANGE
       class Woodie < Pivot
+        register name: :woodie
+
         def compute_value
           p0.input = (t1.high_price + t1.low_price + 2.0 * t0.open_price) / 4.0
         end

data/lib/quant/indicators/rocket_rsi.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class RocketRsiPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+
+      attribute :delta, default: 0.0
+      attribute :gain, default: 0.0
+      attribute :loss, default: 0.0
+
+      attribute :gains, default: 0.0
+      attribute :losses, default: 0.0
+      attribute :denom, default: 0.0
+
+      attribute :inst_rsi, default: 0.5
+      attribute :rsi, default: 0.0
+      attribute :crosses, default: false
+    end
+
+    class RocketRsi < Indicator
+      register name: :rocket_rsi
+
+      def quarter_period
+        half_period / 2
+      end
+
+      def half_period
+        (dc_period / 2) - 1
+      end
+
+      def compute
+        p0.hp = two_pole_butterworth :input, previous: :hp, period: quarter_period
+
+        lp = p(half_period)
+        p0.delta = p0.hp - lp.hp
+        p0.delta > 0.0 ? p0.gain = p0.delta : p0.loss = p0.delta.abs
+
+        period_points(half_period).tap do |period_points|
+          p0.gains = period_points.map(&:gain).sum
+          p0.losses = period_points.map(&:loss).sum
+        end
+
+        p0.denom = p0.gains + p0.losses
+
+        if p0.denom.zero?
+          p0.inst_rsi = p1.inst_rsi
+          p0.rsi = p1.rsi
+        else
+          p0.inst_rsi = ((p0.gains - p0.losses) / p0.denom)
+          p0.rsi = fisher_transform(p0.inst_rsi).clamp(-1.0, 1.0)
+        end
+        p0.crosses = (p0.rsi >= 0.0 && p1.rsi < 0.0) || (p0.rsi <= 0.0 && p1.rsi > 0.0)
+      end
+    end
+  end
+end

data/lib/quant/indicators/roofing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    # The ideal time to buy is when the cycle is at a trough, and the ideal time to exit a long position or to
+    # sell short is when the cycle is at a peak.These conditions are flagged by the filter crossing itself
+    # delayed by two bars, and are included as part of the indicator.
+    class RoofingPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :value, default: 0.0
+      attribute :peak, default: 0.0
+      attribute :agc, default: 0.0
+      attribute :direction, default: 0
+      attribute :turned, default: false
+    end
+
+    class Roofing < Indicator
+      register name: :roofing
+
+      def low_pass_period
+        dc_period
+      end
+
+      def high_pass_period
+        low_pass_period * 2
+      end
+
+      # //Highpass filter cyclic components whose periods are shorter than 48 bars
+      # alpha1 = (Cosine(.707*360 / HPPeriod) + Sine (.707*360 / HPPeriod) - 1) / Cosine(.707*360 / HPPeriod);
+      # HP = (1 - alpha1 / 2)*(1 - alpha1 / 2)*(Close - 2*Close[1] + Close[2]) + 2*(1 - alpha1)*HP[1] - (1 - alpha1)*
+      # (1 - alpha1)*HP[2];
+      # //Smooth with a Super Smoother Filter from equation 3-3
+      # a1 = expvalue(-1.414*3.14159 / LPPeriod);
+      # b1 = 2*a1*Cosine(1.414*180 / LPPeriod);
+      # c2 = b1;
+      # c3 = -a1*a1;
+      # c1 = 1 - c2 - c3;
+      # Filt = c1*(HP + HP[1]) / 2 + c2*Filt[1] + c3*Filt[2
+      def compute
+        a = Math.cos(0.707 * deg2rad(360) / high_pass_period)
+        b = Math.sin(0.707 * deg2rad(360) / high_pass_period)
+        alpha1 = (a + b - 1) / a
+
+        p0.hp = (1 - alpha1 / 2)**2 * (p0.input - 2 * p1.input + p2.input) + 2 * (1 - alpha1) * p1.hp - (1 - alpha1)**2 * p2.hp
+        a1 = Math.exp(-1.414 * Math::PI / low_pass_period)
+        c2 = 2 * a1 * Math.cos(1.414 * deg2rad(180) / low_pass_period)
+        c3 = -a1**2
+        c1 = 1 - c2 - c3
+        p0.value = c1 * (p0.hp + p1.hp) / 2 + c2 * p1.value + c3 * p2.value
+        p0.direction = p0.value > p2.value ? 1 : -1
+        p0.turned = p0.direction != p2.direction
+        # Peak = .991 * Peak[1];
+        # If AbsValue(BP) > Peak Then Peak = AbsValue(BP); If Peak <> 0 Then Signal = BP / Peak;
+        p0.peak = [p0.value.abs, 0.991 * p1.peak].max
+        p0.agc = p0.peak == 0 ? 0 : p0.value / p0.peak
+      end
+    end
+  end
+end

data/lib/quant/indicators/rsi.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class RsiPoint < IndicatorPoint
+      attribute :hp, default: 0.0
+      attribute :filter, default: 0.0
+
+      attribute :delta, default: 0.0
+      attribute :gain, default: 0.0
+      attribute :loss, default: 0.0
+
+      attribute :gains, default: 0.0
+      attribute :losses, default: 0.0
+      attribute :denom, default: 0.0
+
+      attribute :inst_rsi, default: 0.0
+      attribute :rsi, default: 0.0
+    end
+
+    # The Relative Strength Index (RSI) is a momentum oscillator that measures the
+    # speed and change of price movements.  This RSI indicator is adaptive and
+    # uses the half-period of the dominant cycle to calculate the RSI.
+    # It is further smoothed by an exponential moving average of the last three bars
+    # (or whatever the micro_period is set to).
+    #
+    # The RSI oscillates between 0 and 1.  Traditionally, and in this implementation,
+    # the RSI is considered overbought when above 0.7 and oversold when below 0.3.
+    class Rsi < Indicator
+      register name: :rsi
+
+      def quarter_period
+        half_period / 2
+      end
+
+      def half_period
+        (dc_period / 2) - 1
+      end
+
+      def compute
+        # The High Pass filter is half the dominant cycle period while the
+        # Low Pass Filter (super smoother) is the quarter dominant cycle period.
+        p0.hp = high_pass_filter :input, period: half_period
+        p0.filter = ema :hp, previous: :filter, period: quarter_period
+
+        lp = p(half_period)
+        p0.delta = p0.filter - lp.filter
+        p0.delta > 0.0 ? p0.gain = p0.delta : p0.loss = p0.delta.abs
+
+        period_points(half_period).tap do |period_points|
+          p0.gains = period_points.map(&:gain).sum
+          p0.losses = period_points.map(&:loss).sum
+        end
+
+        p0.denom = p0.gains + p0.losses
+
+        if p0.denom > 0.0
+          p0.inst_rsi = (p0.gains / p0.denom)
+          p0.rsi = ema :inst_rsi, previous: :rsi, period: micro_period
+        else
+          p0.inst_rsi = 0.5
+          p0.rsi = 0.5
+        end
+      end
+    end
+  end
+end

data/lib/quant/indicators/snr.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Quant
+  module Indicators
+    class SnrPoint < IndicatorPoint
+      attribute :smooth, default: 0.0
+      attribute :detrend, default: 0.0
+      attribute :i1, default: 0.0
+      attribute :q1, default: 0.0
+      attribute :noise, default: 0.0
+      attribute :signal, default: 0.0
+      attribute :ratio, default: 0.0
+      attribute :state, default: 0
+    end
+
+    class Snr < Indicator
+      register name: :snr
+      depends_on DominantCycles::Homodyne
+
+      def homodyne_dominant_cycle
+        series.indicators[source].dominant_cycles.homodyne
+      end
+
+      def current_dominant_cycle
+        homodyne_dominant_cycle.points[t0]
+      end
+
+      def threshold
+        @threshold ||= 10 * Math.log(0.5)**2
+      end
+
+      def compute_values
+        current_dominant_cycle.tap do |dc|
+          p0.i1 = dc.i1
+          p0.q1 = dc.q1
+        end
+      end
+
+      def compute_noise
+        noise = (p0.input - p2.input).abs
+        p0.noise = p1.noise.zero? ? noise : (0.1 * noise) + (0.9 * p1.noise)
+      end
+
+      def compute_ratio
+        # p0.ratio = 0.25 * (10 * Math.log(p0.i1**2 + p0.q1**2) / Math.log(10)) + 0.75 * p1.ratio
+        # ratio = .25*(10 * Log(I1*I1 + Q1*Q1)/(Range*Range))/Log(10) + 6) + .75*ratio[1]
+        if p0 == p1
+          p0.signal = 0.0
+          p0.ratio = 1.0
+        else
+          p0.signal = threshold + 10.0 * (Math.log((p0.i1**2 + p0.q1**2)/(p0.noise**2)) / Math.log(10))
+          p0.ratio = (0.25 * p0.signal) + (0.75 * p1.ratio)
+        end
+        p0.state = p0.ratio >= threshold ? 1 : 0
+      end
+
+      def compute
+        compute_values
+        compute_noise
+        compute_ratio
+      end
+    end
+  end
+end

data/lib/quant/indicators_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quant
+  module IndicatorsRegistry
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def define_indicator_accessors(indicator_source:)
+      self.class.define_indicator_accessors(indicator_source:)
+    end
+
+    module ClassMethods
+      def registry
+        @registry ||= {}
+      end
+
+      class RegistryEntry
+        attr_reader :name, :indicator_class
+
+        def initialize(name:, indicator_class:)
+          @name = name
+          @indicator_class = indicator_class
+        end
+
+        def key
+          "#{indicator_class.name}::#{name}"
+        end
+
+        def standard?
+          !pivot? && !dominant_cycle?
+        end
+
+        def pivot?
+          indicator_class < Indicators::Pivots::Pivot
+        end
+
+        def dominant_cycle?
+          indicator_class < Indicators::DominantCycles::DominantCycle
+        end
+      end
+
+      def register(name:, indicator_class:)
+        entry = RegistryEntry.new(name:, indicator_class:)
+        registry[entry.key] = entry
+        # registry[name] = indicator_class
+      end
+
+      def registry_entries_for(indicator_source:)
+        return registry.values.select(&:pivot?) if indicator_source.is_a?(PivotsSource)
+        return registry.values.select(&:dominant_cycle?) if indicator_source.is_a?(DominantCyclesSource)
+
+        registry.values.select(&:standard?)
+      end
+
+      def define_indicator_accessors(indicator_source:)
+        registry_entries_for(indicator_source:).each do |entry|
+          indicator_source.define_singleton_method(entry.name) { indicator(entry.indicator_class) }
+        end
+      end
+    end
+  end
+end