quantitative 0.3.0 → 0.3.2

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

@@ -1,9 +1,10 @@
-require_relative '../pivot'
 
 module Quant
-  class Indicators
-    class Pivots
+  module Indicators
+    module Pivots
       class Murrey < Pivot
+        register name: :murrey
+
         def multiplier
           0.125
         end

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

@@ -0,0 +1,109 @@
+module Quant
+  module Indicators
+    module Pivots
+      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::Pivots::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
+end

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

@@ -1,7 +1,9 @@
 module Quant
-  class Indicators
-    class Pivots
+  module Indicators
+    module Pivots
       class Traditional < Pivot
+        register name: :traditional
+
         def multiplier
           2.0
         end

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

@@ -1,8 +1,8 @@
-require_relative '../pivot'
+# frozen_string_literal: true
 
 module Quant
-  class Indicators
-    class Pivots
+  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
@@ -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.rb

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

data/lib/quant/indicators_source.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "dominant_cycles_source"
 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.
@@ -17,13 +16,18 @@ module Quant
   # By design, the {Quant::Indicators::Indicator} class holds the {Quant::Ticks::Tick} instance
   # alongside the indicator's computed values for that tick.
   class IndicatorsSource
+    include IndicatorsRegistry
+
     attr_reader :series, :source, :dominant_cycles, :pivots
 
     def initialize(series:, source:)
       @series = series
       @source = source
+
       @indicators = {}
       @ordered_indicators = []
+      define_indicator_accessors(indicator_source: self)
+
       @dominant_cycles = DominantCyclesSource.new(indicator_source: self)
       @pivots = PivotsSource.new(indicator_source: self)
     end
@@ -36,20 +40,19 @@ module Quant
       @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.
     #
+    # NOTE: You can also use the `register` method on the indicator class to
+    # accomplish the same thing.  `attach` lets you inject a custom indicator
+    # at run-time when you have an instance of {Quant::IndicatorsSource} while
+    # the `register` method is used to define the indicator at load-time.
+    #
+    # NOTE Calling `attach` also registers the indicator with the framework, so
+    # you only have to `attach` once.
+    #
     # 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.
     #
@@ -58,6 +61,7 @@ module Quant
     # @example
     #   series.indicators.oc2.attach(name: :foo, indicator_class: Indicators::Foo)
     def attach(name:, indicator_class:)
+      self.class.register(name:, indicator_class:)
       define_singleton_method(name) { indicator(indicator_class) }
     end
 

data/lib/quant/mixins/filters.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "high_pass_filters"
-require_relative "butterworth_filters"
-require_relative "universal_filters"
 module Quant
   module Mixins
     module Filters

data/lib/quant/mixins/moving_averages.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "weighted_moving_average"
-require_relative "simple_moving_average"
-require_relative "exponential_moving_average"
 module Quant
   module Mixins
     module MovingAverages

data/lib/quant/pivots_source.rb

@@ -4,21 +4,9 @@ module Quant
   class PivotsSource
     def initialize(indicator_source:)
       @indicator_source = indicator_source
+      indicator_source.define_indicator_accessors(indicator_source: self)
     end
 
-    def atr; indicator(Indicators::Pivots::Atr) end
-    def bollinger; indicator(Indicators::Pivots::Bollinger) end
-    def camarilla; indicator(Indicators::Pivots::Camarilla) end
-    def classic; indicator(Indicators::Pivots::Classic) end
-    def demark; indicator(Indicators::Pivots::Demark) end
-    def donchian; indicator(Indicators::Pivots::Donchian) end
-    def fibbonacci; indicator(Indicators::Pivots::Fibbonacci) end
-    def guppy; indicator(Indicators::Pivots::Guppy) end
-    def keltner; indicator(Indicators::Pivots::Keltner) end
-    def murrey; indicator(Indicators::Pivots::Murrey) end
-    def traditional; indicator(Indicators::Pivots::Traditional) end
-    def woodie; indicator(Indicators::Pivots::Woodie) end
-
     private
 
     def indicator(indicator_class)

data/lib/quant/ticks/ohlc.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "tick"
-
 module Quant
   module Ticks
     # A {Quant::Ticks::OHLC} is a bar or candle for a point in time that

data/lib/quant/ticks/spot.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "tick"
-
 module Quant
   module Ticks
     # A +Spot+ is a single price point in time.  It is the most basic form of a {Quant::Ticks::Tick} and is usually used to represent

data/lib/quant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quant
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

data/lib/quantitative.rb

@@ -4,14 +4,37 @@ require "time"
 require "date"
 require "oj"
 require "csv"
+require "zeitwerk"
 
 lib_folder = File.expand_path(File.join(File.dirname(__FILE__)))
 quant_folder = File.join(lib_folder, "quant")
 
-# require top-level files
-Dir.glob(File.join(quant_folder, "*.rb")).each { |fn| require fn }
-
-# require sub-folders and their sub-folders
-%w(refinements mixins statistics settings ticks indicators).each do |sub_folder|
-  Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
+# Explicitly require module functions since Zeitwerk isn't configured, yet.
+require_relative "quant/time_methods"
+require_relative "quant/config"
+require_relative "quant/experimental"
+module Quant
+  include TimeMethods
+  include Config
+  include Experimental
 end
+
+# Configure Zeitwerk to autoload the Quant module.
+loader = Zeitwerk::Loader.for_gem
+loader.push_dir(quant_folder, namespace: Quant)
+
+loader.inflector.inflect "ohlc" => "OHLC"
+loader.inflector.inflect "version" => "VERSION"
+
+loader.setup
+
+# Refinements aren't autoloaded by Zeitwerk, so we need to require them manually.
+# %w(refinements).each do |sub_folder|
+#   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
+# end
+
+refinements_folder = File.join(quant_folder, "refinements")
+indicators_folder = File.join(quant_folder, "indicators")
+
+loader.eager_load_dir(refinements_folder)
+loader.eager_load_dir(indicators_folder)