quantitative 0.1.0

data/lib/quant/mixins/filters.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    # 1.  All the common filters useful for traders have a transfer response that can be written
+    #     as a ratio of two polynomials.
+    # 2.  Lag is very important to traders. More complex filters can be created using more input data,
+    #     but more input data increases lag. Sophisticated filters are not very useful for trading
+    #     because they incur too much lag.
+    # 3.  Filter transfer response can be viewed in the time domain and the frequency domain with equal validity.
+    # 4.  Nonrecursive filters can have zeros in the transfer response, enabling the complete cancellation of
+    #     some selected frequency components.
+    # 5.  Nonrecursive filters having coefficients symmetrical about the center of the filter will have a delay
+    #     of half the degree of the transfer response polynomial at all frequencies.
+    # 6.  Low-pass filters are smoothers because they attenuate the high-frequency components of the input data.
+    # 7.  High-pass filters are detrenders because they attenuate the low-frequency components of trends.
+    # 8.  Band-pass filters are both detrenders and smoothers because they attenuate all but the desired frequency components.
+    # 9.  Filters provide an output only through their transfer response. The transfer response is strictly a
+    #     mathematical function, and interpretations such as overbought, oversold, convergence, divergence,
+    #     and so on are not implied. The validity of such interpretations must be made on the basis of
+    #     statistics apart from the filter.
+    # 10. The critical period of a filter output is the frequency at which the output power of the filter
+    #     is half the power of the input wave at that frequency.
+    # 11. A WMA has little or no redeeming virtue.
+    # 12. A median filter is best used when the data contain impulsive noise or when there are wild
+    #     variations in the data. Smoothing volume data is one example of a good application for a
+    #     median filter.
+    #
+    # Filter Coefficients forVariousTypes of Filters
+    # Filter Type           b0          b1              b2          a0        a1        a2
+    # EMA                   α           0               0           1         −(1−α)    0
+    # Two-pole low-pass     α**2        0               0           1         −2*(1-α)  (1-α)**2
+    # High-pass             (1-α/2)     -(1-α/2)        0           1         −(1−α)    0
+    # Two-pole high-pass    (1-α/2)**2  -2*(1-α/2)**2   (1-α/2)**2  1         -2*(1-α)  (1-α)**2
+    # Band-pass             (1-σ)/2     0               -(1-σ)/2    1         -λ*(1+σ)  σ
+    # Band-stop             (1+σ)/2     -2λ*(1+σ)/2     (1+σ)/2     1         -λ*(1+σ)  σ
+    module Filters
+      include Mixins::Trig
+
+      # α = Cos(K*360/Period)+Sin(K*360/Period)−1 / Cos(K*360/Period)
+      # k = 1.0 for single-pole filters
+      # k = 0.707 for two-pole high-pass filters
+      # k = 1.414 for two-pole low-pass filters
+      def period_to_alpha(period, k: 1.0)
+        radians = deg2rad(k * 360 / period)
+        cos = Math.cos(radians)
+        sin = Math.sin(radians)
+        (cos + sin - 1) / cos
+      end
+
+      # 3 bars = 0.5
+      # 4 bars = 0.4
+      # 5 bars = 0.333
+      # 6 bars = 0.285
+      # 10 bars = 0.182
+      # 20 bars = 0.0952
+      # 40 bars = 0.0488
+      # 50 bars = 0.0392
+      def bars_to_alpha(bars)
+        2.0 / (bars + 1)
+      end
+
+      def ema(source, prev_source, period)
+        alpha = bars_to_alpha(period)
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+        v1 = p1.send(prev_source)
+        (v0 * alpha) + (v1 * (1 - alpha))
+      end
+
+      def band_pass(source, prev_source, period, bandwidth); end
+
+      def two_pole_butterworth(source, prev_source, period)
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+
+        v1 = 0.5 * (v0 + p1.send(source))
+        v2 = p1.send(prev_source)
+        v3 = p2.send(prev_source)
+
+        radians = Math.sqrt(2) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+
+        c2 = b
+        c3 = -a**2
+        c1 = 1.0 - c2 - c3
+
+        (c1 * v1) + (c2 * v2) + (c3 * v3)
+      end
+
+      def three_pole_butterworth(source, prev_source, period)
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+        return v0 if p2 == p3
+
+        v1 = p1.send(prev_source)
+        v2 = p2.send(prev_source)
+        v3 = p3.send(prev_source)
+
+        radians = Math.sqrt(3) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+        c = a**2
+
+        d4 = c**2
+        d3 = -(c + (b * c))
+        d2 = b + c
+        d1 = 1.0 - d2 - d3 - d4
+
+        (d1 * v0) + (d2 * v1) + (d3 * v2) + (d4 * v3)
+      end
+    end
+  end
+end

data/lib/quant/mixins/fisher_transform.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    # Fisher Transforms
+    # • Price is not a Gaussian (Bell Curve) distribution, even though many technical analysis formulas
+    #   falsely assume that it is. Bell Curve tails are missing.
+    #   – If $10 stock were Gaussian, it could go up or down $20 – Standard deviation based indicators like Bollinger Bands
+    #   and zScore make the Gaussian assumption error
+    # • TheFisher Transform converts almost any probability distribution in a Gaussian-like one
+    #   – Expands the distribution and creates tails
+    # • The Inverse Fisher Transform converts almost any probability distribution into a square wave
+    #   – Compresses, removes low amplitude variations
+    module FisherTransform
+      # inverse fisher transform
+      # https://www.mql5.com/en/articles/303
+      def ift(value, scale_factor = 1.0)
+        r = (Math.exp(2.0 * scale_factor * value) - 1.0) / (Math.exp(2.0 * scale_factor * value) + 1.0)
+        r.nan? ? 0.0 : r
+      end
+
+      # def fisher_transform(value, max_value)
+      #   return 0.0 if max_value.zero?
+      #   x = (value / max_value).abs
+      #   r = 0.5 * Math.log((1 + x) / (1 - x))
+      #   r.nan? ? 0.0 : r
+      # end
+
+      # The absolute value passed must be < 1.0
+      def fisher_transform(value)
+        r = 0.5 * Math.log((1.0 + value) / (1.0 - value))
+        r.nan? ? 0.0 : r
+      rescue Math::DomainError => e
+        raise "value #{value}: #{(1 + value) / (1 - value)}, e: #{e}"
+      end
+    end
+  end
+end

data/lib/quant/mixins/high_pass_filter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module HighPassFilter
+      # HighPass Filters are “detrenders” because they attenuate low frequency components
+      # One pole HighPass and SuperSmoother does not produce a zero mean because low
+      # frequency spectral dilation components are “leaking” through The one pole
+      # HighPass Filter response
+      def two_pole_high_pass_filter(source, prev_source, min_period, max_period = nil)
+        raise "source must be a symbol" unless source.is_a?(Symbol)
+        return p0.send(source) if p0 == p2
+
+        max_period ||= min_period * 2
+        (min_period * Math.sqrt(2))
+        max_radians = 2.0 * Math::PI / (max_period * Math.sqrt(2))
+
+        v1 = p0.send(source) - (2.0 * p1.send(source)) + p2.send(source)
+        v2 = p1.send(prev_source)
+        v3 = p2.send(prev_source)
+
+        alpha = period_to_alpha(max_radians)
+
+        a = (1 - (alpha * 0.5))**2 * v1
+        b = 2 * (1 - alpha) * v2
+        c = (1 - alpha)**2 * v3
+
+        a + b - c
+      end
+
+      # alpha = (Cosine(.707* 2 * PI / 48) + Sine (.707*360 / 48) - 1) / Cosine(.707*360 / 48);
+      # is the same as the following:
+      # radians = Math.sqrt(2) * Math::PI / period
+      # alpha = (Math.cos(radians) + Math.sin(radians) - 1) / Math.cos(radians)
+      def high_pass_filter(source, period)
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+        return v0 if p3 == p0
+
+        v1 = p1.send(source)
+        v2 = p2.send(source)
+
+        radians = Math.sqrt(2) * Math::PI / period
+        a = Math.exp(-radians)
+        b = 2 * a * Math.cos(radians)
+
+        c2 = b
+        c3 = -a**2
+        c1 = (1 + c2 - c3) / 4
+
+        (c1 * (v0 - (2 * v1) + v2)) + (c2 * p1.hp) + (c3 * p2.hp)
+      end
+    end
+  end
+end

data/lib/quant/mixins/hilbert_transform.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module HilbertTransform
+      def hilbert_transform(source, period = p1.period)
+        [0.0962 * p0.send(source),
+         0.5769 * p2.send(source),
+         -0.5769 * prev(4).send(source),
+         -0.0962 * prev(6).send(source),].sum * ((0.075 * period) + 0.54)
+      end
+    end
+  end
+end

data/lib/quant/mixins/stochastic.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module Stochastic
+      def stochastic(source, period = max_period)
+        stoch_period = [points.size, period.to_i].min
+        return 0.0 if stoch_period < 1
+
+        subset = points[-stoch_period, stoch_period].map{ |p| p.send(source) }
+        ll = subset.min
+        hh = subset.max
+
+        v0 = points[-1].send(source)
+        (hh - ll).zero? ? 0.0 : 100.0 * (v0 - ll) / (hh - ll)
+      end
+
+      # module Fields
+      #   @[JSON::Field(key: "ish")]
+      #   property inst_stoch : Float64 = 0.0
+      #   @[JSON::Field(key: "sh")]
+      #   property stoch : Float64 = 0.0
+      #   @[JSON::Field(key: "su")]
+      #   property stoch_up : Bool = false
+      #   @[JSON::Field(key: "st")]
+      #   property stoch_turned : Bool = false
+      # end
+    end
+  end
+end

data/lib/quant/mixins/super_smoother.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module SuperSmoother
+      def super_smoother(source, prev_source, period)
+        v0 = (source.is_a?(Symbol) ? p0.send(source) : source).to_d
+        return v0.to_f if points.size < 4
+
+        k = Math.exp(-Math.sqrt(2) * Math::PI / period)
+        coef3 = -k**2
+        coef2 = 2.0 * k * Math.cos(Math.sqrt(2) * (Math::PI / 2) / period)
+        coef1 = 1.0 - coef2 - coef3
+
+        v1 = p1.send(prev_source).to_d
+        v2 = p2.send(prev_source).to_d
+        p3.send(prev_source).to_d
+        ((coef1 * (v0 + v1)) / 2.0 + (coef2 * v1) + (coef3 * v2)).to_f
+      end
+
+      def two_pole_super_smooth(source, prev_source, ssperiod)
+        return p1.send(source) if [p1 == p3]
+
+        radians = Math::PI * Math.sqrt(2) / ssperiod
+        a1 = Math.exp(-radians)
+
+        coef2 = 2.0 * a1 * Math.cos(radians)
+        coef3 = -a1 * a1
+        coef1 = 1.0 - coef2 - coef3
+
+        v0 = (p1.send(source) + p2.send(source)) / 2.0
+        v1 = p2.send(prev_source)
+        v2 = p3.send(prev_source)
+        (coef1 * v0) + (coef2 * v1) + (coef3 * v2)
+      end
+
+      def three_pole_super_smooth(source, prev_source, ssperiod)
+        a1 = Math.exp(-Math::PI / ssperiod)
+        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / ssperiod)
+        c1 = a1**2
+
+        coef2 = b1 + c1
+        coef3 = -(c1 + b1 * c1)
+        coef4 = c1**2
+        coef1 = 1 - coef2 - coef3 - coef4
+
+        p0 = prev(0)
+        p1 = prev(1)
+        p2 = prev(2)
+        p3 = prev(3)
+
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+        return v0 if [p0, p1, p2].include?(p3)
+
+        v1 = p1.send(prev_source)
+        v2 = p2.send(prev_source)
+        v3 = p3.send(prev_source)
+        (coef1 * v0) + (coef2 * v1) + (coef3 * v2) + (coef4 * v3)
+      end
+
+      # super smoother 3 pole
+      def ss3p(source, prev_source, ssperiod)
+        p0 = points[-1]
+        p1 = points[-2] || p0
+        p2 = points[-3] || p1
+        p3 = points[-4] || p2
+
+        v0 = source.is_a?(Symbol) ? p0.send(source) : source
+        return v0 if [p0 == p3]
+
+        debugger if points.size > 4
+        a1 = Math.exp(-Math::PI / ssperiod)
+        b1 = 2 * a1 * Math.cos(Math::PI * Math.sqrt(3) / ssperiod)
+        c1 = a1**2
+
+        coef2 = b1 + c1
+        coef3 = -(c1 + b1 * c1)
+        coef4 = c1**2
+        coef1 = 1 - coef2 - coef3 - coef4
+
+        v1 = p1.send(prev_source)
+        v2 = p2.send(prev_source)
+        v3 = p3.send(prev_source)
+        (coef1 * v0) + (coef2 * v1) + (coef3 * v2) + (coef4 * v3)
+      end
+
+      #   attr_reader :hpfs, :value1s, :hpf_psns
+
+      #   def hpf
+      #     @hpfs[-1]
+      #   end
+
+      #   def hpf_psn
+      #     @hpf_psns[-1]
+      #   end
+
+      #   def prev offset, source
+      #     idx = offset + 1
+      #     source[[-idx, -source.size].max]
+      #   end
+
+      #   def weighted_average source
+      #     [ 4.0 * prev(0, source),
+      #       3.0 * prev(1, source),
+      #       2.0 * prev(2, source),
+      #             prev(3, source),
+      #     ].sum / 10.0
+      #   end
+
+      #   def compute_hpf
+      #     @hpfs ||= []
+      #     @value1s ||= []
+      #     @hpf_psns ||= []
+      #     max_cycle = period * 10
+
+      #     r = (360.0 / max_cycle) * (Math::PI / 180)
+      #     alpha = (1 - Math::sin(r)) / Math::cos(r)
+      #     hpf = @hpfs.empty? ? 0.0 : (0.5 * (1.0 + alpha) * (current_value - prev_value(1))) + (alpha * (@hpfs[-1]))
+
+      #     @hpfs << hpf
+      #     @hpfs.shift if @hpfs.size > max_cycle
+
+      #     hh = @hpfs.max
+      #     ll = @hpfs.min
+      #     @value1s << value1 = (hh == ll ? 0.0 : 100 * (hpf - ll) / (hh - ll))
+      #     @value1s.shift if @value1s.size > max_cycle
+
+      #     @hpf_psns << weighted_average(@value1s)
+      #     @hpf_psns.shift if @hpf_psns.size > max_cycle
+      #   end
+    end
+  end
+end

data/lib/quant/mixins/trig.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module Trig
+      def deg2rad(degrees)
+        degrees * Math::PI / 180.0
+      end
+
+      def rad2deg(radians)
+        radians * 180.0 / Math::PI
+      end
+
+      # dx1 = x2-x1;
+      # dy1 = y2-y1;
+      # dx2 = x4-x3;
+      # dy2 = y4-y3;
+
+      # d = dx1*dx2 + dy1*dy2;   // dot product of the 2 vectors
+      # l2 = (dx1*dx1+dy1*dy1)*(dx2*dx2+dy2*dy2) // product of the squared lengths
+      def angle(line1, line2)
+        dx1 = line2[0][0] - line1[0][0]
+        dy1 = line2[0][1] - line1[0][1]
+        dx2 = line2[1][0] - line1[1][0]
+        dy2 = line2[1][1] - line1[1][1]
+
+        d = dx1 * dx2 + dy1 * dy2
+        l2 = (dx1**2 + dy1**2) * (dx2**2 + dy2**2)
+        rad2deg Math.acos(d / Math.sqrt(l2))
+      end
+
+      # angle = acos(d/sqrt(l2))
+      #     public static double angleBetween2Lines(Line2D line1, Line2D line2)
+      # {
+      #     double angle1 = Math.atan2(line1.getY1() - line1.getY2(),
+      #                                line1.getX1() - line1.getX2());
+      #     double angle2 = Math.atan2(line2.getY1() - line2.getY2(),
+      #                                line2.getX1() - line2.getX2());
+      #     return angle1-angle2;
+      # }
+    end
+  end
+end

data/lib/quant/mixins/weighted_average.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module WeightedAverage
+      def weighted_average(source)
+        value = source.is_a?(Symbol) ? p0.send(source) : source
+        [4.0 * value,
+         3.0 * p1.send(source),
+         2.0 * p2.send(source),
+         p3.send(source),].sum / 10.0
+      end
+
+      def extended_weighted_average(source)
+        value = source.is_a?(Symbol) ? p0.send(source) : source
+        [7.0 * value,
+         6.0 * p1.send(source),
+         5.0 * p2.send(source),
+         4.0 * p3.send(source),
+         3.0 * prev(4).send(source),
+         2.0 * prev(5).send(source),
+         prev(6).send(source),].sum / 28.0
+      end
+    end
+  end
+end

data/lib/quant/ticks/core.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Quant
+  module Ticks
+    class Core
+    end
+  end
+end

data/lib/quant/ticks/indicator_points.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Quant
+  module Ticks
+    class IndicatorPoints
+      attr_reader :points
+
+      def initialize(tick:)
+        @tick = tick
+        @points = {}
+      end
+
+      def [](indicator)
+        points[indicator]
+      end
+
+      def []=(indicator, point)
+        points[indicator] = point
+      end
+    end
+  end
+end

data/lib/quant/ticks/ohlc.rb

@@ -0,0 +1,152 @@
+require_relative 'value'
+
+module Quant
+  module Ticks
+    # serialized keys
+    # ot: open timestamp
+    # ct: close timestamp
+    # iv: interval
+
+    # o: open price
+    # h: high price
+    # l: low price
+    # c: close price
+
+    # bv: base volume
+    # tv: target volume
+    # ct: close timestamp
+
+    # t: trades
+    # g: green
+    # j: doji
+    class OHLC < Value
+      def self.from(hash)
+        new \
+          open_timestamp: hash["ot"],
+          close_timestamp: hash["ct"],
+          interval: hash["iv"],
+
+          open_price: hash["o"],
+          high_price: hash["h"],
+          low_price: hash["l"],
+          close_price: hash["c"],
+
+          base_volume: hash["bv"],
+          target_volume: hash["tv"],
+
+          trades: hash["t"],
+          green: hash["g"],
+          doji: hash["j"]
+      end
+
+      def self.from_json(json)
+        from Oj.load(json)
+      end
+
+      def initialize(open_timestamp:,
+                     close_timestamp:,
+                     interval: nil,
+
+                     open_price:,
+                     high_price:,
+                     low_price:,
+                     close_price:,
+
+                     base_volume: 0.0,
+                     target_volume: 0.0,
+
+                     trades: 0,
+                     green: false,
+                     doji: nil)
+
+        super(price: close_price, timestamp: close_timestamp, interval:, trades:)
+        @open_timestamp = extract_time(open_timestamp)
+        @open_price = open_price.to_f
+        @high_price = high_price.to_f
+        @low_price = low_price.to_f
+
+        @base_volume = base_volume.to_i
+        @target_volume = target_volume.to_i
+
+        @green = green.nil? ? compute_green : green
+        @doji = doji.nil? ? compute_doji : doji
+      end
+
+      def hl2; ((high_price + low_price) / 2.0) end
+      def oc2; ((open_price + close_price) / 2.0) end
+      def hlc3; ((high_price + low_price + close_price) / 3.0) end
+      def ohlc4; ((open_price + high_price + low_price + close_price) / 4.0) end
+
+      def corresponding?(other)
+        [open_timestamp, close_timestamp] == [other.open_timestamp, other.close_timestamp]
+      end
+
+      # percent change from open to close
+      def delta
+        ((open_price / close_price) - 1.0) * 100
+      end
+
+      def to_h
+        { "ot" => open_timestamp,
+          "ct" => close_timestamp,
+          "iv" => interval.to_s,
+
+          "o" => open_price,
+          "h" => high_price,
+          "l" => low_price,
+          "c" => close_price,
+
+          "bv" => base_volume,
+          "tv" => target_volume,
+
+          "t" => trades,
+          "g" => green,
+          "j" => doji }
+      end
+
+      def as_price(value)
+        series.nil? ? value : series.as_price(value)
+      end
+
+      def to_s
+        ots = interval.daily? ? open_timestamp.strftime('%Y-%m-%d') : open_timestamp.strftime('%Y-%m-%d %H:%M:%S')
+        cts = interval.daily? ? close_timestamp.strftime('%Y-%m-%d') : close_timestamp.strftime('%Y-%m-%d %H:%M:%S')
+        "#{ots}: o: #{as_price(open_price)}, h: #{as_price(high_price)}, l: #{as_price(low_price)}, c: #{as_price(close_price)} :#{cts}"
+      end
+
+      def compute_green
+        close_price >= open_price
+      end
+
+      def green?
+        close_price > open_price
+      end
+
+      def red?
+        !green?
+      end
+
+      def doji?
+        @doji
+      end
+
+      def price_change
+        @price_change ||= ((open_price - close_price) / oc2).abs
+      end
+
+      def compute_doji
+        body_bottom, body_top = [open_price, close_price].sort
+
+        body_length = body_top - body_bottom
+        head_length = high_price - [open_price, close_price].max
+        tail_length = [open_price, close_price].max - low_price
+
+        body_ratio = 100.0 * (1 - (body_bottom / body_top))
+        head_ratio = head_length / body_length
+        tail_ratio = tail_length / body_length
+
+        body_ratio < 0.025 && head_ratio > 1.0 && tail_ratio > 1.0
+      end
+    end
+  end
+end

data/lib/quant/ticks/serializers/value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Quant
+  module Ticks
+    module Serializers
+      module Value
+        module_function
+
+        def to_h(instance)
+          { "iv" => instance.interval.to_s,
+            "ct" => instance.close_timestamp.to_i,
+            "cp" => instance.close_price,
+            "bv" => instance.base_volume,
+            "tv" => instance.target_volume }
+        end
+
+        def to_json(instance)
+          Oj.dump to_h(instance)
+        end
+      end
+    end
+  end
+end

data/lib/quant/ticks/spot.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Quant
+  module Ticks
+    class Spot < Value
+      def self.from(hash)
+        new(close_timestamp: hash["ct"], close_price: hash["c"], base_volume: hash["bv"], target_volume: hash["tv"])
+      end
+
+      def self.from_json(json)
+        from Oj.load(json)
+      end
+
+      def initialize(close_timestamp:, close_price:, interval: nil, base_volume: 0.0, target_volume: 0.0, trades: 0)
+        super(price: close_price, timestamp: close_timestamp, interval: interval, volume: base_volume, trades: trades)
+        @target_volume = target_volume.to_i
+      end
+
+      def corresponding?(other)
+        close_timestamp == other.close_timestamp
+      end
+
+      def to_h
+        { "ct" => close_timestamp,
+          "c" => close_price,
+          "iv" => interval.to_s,
+          "bv" => base_volume,
+          "tv" => target_volume,
+          "t" => trades }
+      end
+    end
+  end
+end