quantitative 0.1.3 → 0.1.5

data/lib/quant/interval.rb

@@ -39,13 +39,13 @@
 #   pp series
 #
 module Quant
-  # +Quant::Interval+ abstracts away the concept of ticks (candles, bars, etc.) and their duration and offers some basic utilities for
-  # working with multiple timeframes.  Intervals are used in +Tick+ and +Series+ classes to define the duration of the ticks.
+  # {Quant::Interval} abstracts away the concept of ticks (candles, bars, etc.) and their duration and offers some basic utilities for
+  # working with multiple timeframes.  Intervals are used in {Quant::Ticks::Tick} and {Quant::Series} classes to define the duration of the ticks.
   #
-  # When the +Interval+ is unknown, it is set to +'na'+ (not available) and the duration is set to 0.  The shorthand for this is
+  # When the {Quant::Interval} is unknown, it is set to +'na'+ (not available) and the duration is set to 0.  The shorthand for this is
   # +Interval.na+. and +Interval[:na]+. and +Interval[nil]+.
   #
-  # +Interval+ are instantiated in multple ways to support a wide variety of use-cases.  Here's an example:
+  # {Quant::Interval} are instantiated in multple ways to support a wide variety of use-cases.  Here's an example:
   #   Quant::Interval.new("1d")               # => #<Quant::Interval @interval="1d"> (daily interval)
   #   Quant::Interval.new(:daily)             # => #<Quant::Interval @interval="1d">
   #   Quant::Interval[:daily]                 # => #<Quant::Interval @interval="1d">
@@ -122,7 +122,7 @@ module Quant
 
     # Instantiates an Interval from a resolution.  For example, TradingView uses resolutions
     # like "1", "3", "5", "15", "30", "60", "240", "D", "1D" to represent the duration of a
-    # candlestick.  +from_resolution+ translates resolutions to the appropriate +Interval+.
+    # candlestick.  +from_resolution+ translates resolutions to the appropriate {Quant::Interval}.
     def self.from_resolution(resolution)
       ensure_valid_resolution!(resolution)
 
@@ -130,7 +130,7 @@ module Quant
     end
 
     # Instantiates an Interval from a string or symbol.  If the value is already
-    # an +Interval+, it is returned as-is.
+    # an {Quant::Interval}, it is returned as-is.
     def self.[](value)
       return value if value.is_a? Interval
 
@@ -153,19 +153,28 @@ module Quant
       @interval = (interval || "na").to_s
     end
 
+    # Returns true when the duration of the interval is zero, such as for the `na` interval.
     def nil?
-      interval == "na"
+      duration.zero?
     end
 
     def to_s
       interval
     end
 
+    # Returns the total span of seconds or duration for the interval.
+    # @example
+    #   Quant::Interval.new("1d").duration => 86400
+    #   Quant::Interval.new("1h").duration => 3600
+    #   Quant::Interval.new("1m").duration => 60
+    #   Quant::Interval.new("1s").duration => 1
+    #   Quant::Interval.new("na").duration => 0
     def duration
       INTERVAL_DISTANCE[interval]
     end
     alias seconds duration
 
+    # Compares the interval to another interval, string, or symbol and returns true if they are equal.
     def ==(other)
       if other.is_a? String
         interval.to_s == other
@@ -176,13 +185,22 @@ module Quant
       end
     end
 
+    # Returns the number of ticks this interval represents per minute.
+    # @example
+    #   Quant::Interval.new("1d").ticks_per_minute => 0.0006944444444444445
+    #   Quant::Interval.new("1h").ticks_per_minute => 0.016666666666666666
+    #   Quant::Interval.new("1m").ticks_per_minute => 1.0
+    #   Quant::Interval.new("1s").ticks_per_minute => 60.0
     def ticks_per_minute
       60.0 / seconds
     end
 
+    # Returns the half-life of the interval in seconds.
+    # @example
+    #   Quant::Interval.new("1d").half_life => 43200.0
+    #   Quant::Interval.new("1h").half_life => 1800.0
+    #   Quant::Interval.new("1m").half_life => 30.0
     def half_life
-      raise "bad interval #{interval}" if duration.nil?
-
       duration / 2.0
     end
 
@@ -193,11 +211,16 @@ module Quant
       Interval.new intervals[intervals.index(interval) + 1] || intervals[-1]
     end
 
+    # Returns the full list of valid interval Strings that can be used to instantiate an {Quant::Interval}.
     def self.valid_intervals
       INTERVAL_DISTANCE.keys
     end
 
-    # NOTE: if timestamp doesn't cover a full interval, it will be rounded up to 1
+    # Computes the number of ticks from present to given timestamp.
+    # If timestamp doesn't cover a full interval, it will be rounded up to 1
+    # @example
+    #   interval = Quant::Interval.new("1d")
+    #   interval.ticks_to(Time.now + 5.days) # => 5  NOTE: `5.days` is an ActiveSupport method
     def ticks_to(timestamp)
       ((timestamp - Quant.current_time) / duration).round(2).ceil
     end
@@ -209,7 +232,8 @@ module Quant
     def self.ensure_valid_resolution!(resolution)
       return if RESOLUTIONS.keys.include? resolution
 
-      raise InvalidResolution, "resolution (#{resolution}) not a valid resolution. Should be one of: (#{RESOLUTIONS.keys.join(", ")})"
+      should_be_one_of = "Should be one of: (#{RESOLUTIONS.keys.join(", ")})"
+      raise Errors::InvalidResolution, "resolution (#{resolution}) not a valid resolution. #{should_be_one_of}"
     end
 
     private
@@ -221,7 +245,8 @@ module Quant
     def ensure_valid_interval!(interval)
       return if interval.nil? || valid_intervals.include?(interval.to_s)
 
-      raise InvalidInterval, "interval (#{interval.inspect}) not a valid interval. Should be one of: (#{valid_intervals.join(", ")})"
+      should_be_one_of = "Should be one of: (#{valid_intervals.join(", ")})"
+      raise Errors::InvalidInterval, "interval (#{interval.inspect}) not a valid interval. #{should_be_one_of}"
     end
 
     def ensure_valid_resolution!(resolution)

data/lib/quant/mixins/filters.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "trig"
+
 module Quant
   module Mixins
     # 1.  All the common filters useful for traders have a transfer response that can be written

data/lib/quant/refinements/array.rb

@@ -1,6 +1,6 @@
 module Quant
   module Refinements
-    # Refinements for the standard Ruby +Array+ class.
+    # Refinements for the standard Ruby {Quant::Array} class.
     # These refinements add statistical methods to the Array class as well as some optimizations that greatly
     # speed up some of the computations performed by the various indicators.
     #
@@ -67,7 +67,7 @@ module Quant
       end
 
       # Treats the tail of the array as starting at zero and counting up.  Does not overflow the head of the array.
-      # That is, if the +Array+ has 5 elements, prev(10) would return the first element in the array.
+      # That is, if the {Quant::Array} has 5 elements, prev(10) would return the first element in the array.
       #
       # @example
       #   series = [1, 2, 3, 4]
@@ -89,11 +89,12 @@ module Quant
       # +max_size+, the first element is removed from the array.
       # This setting modifies :<< and :push methods.
       def max_size!(max_size)
-        # These guards are maybe not necessary, but they are here until a use-case is found.
-        # My concern lies with indicators that are built specifically against the +max_size+ of a given array.
-        raise Quant::ArrayMaxSizeError, 'cannot set max_size to nil.' unless max_size
-        raise Quant::ArrayMaxSizeError, 'can only max_size! once.' if @max_size
-        raise Quant::ArrayMaxSizeError, "size of Array #{size} exceeds max_size #{max_size}." if size > max_size
+        # These guards are maybe unnecessary, but they are here until a use-case is found.
+        # Some indicators are built specifically against the +max_size+ of a given array.
+        # Adjusting the +max_size+ after the fact could lead to unexpected, unintended behavior.
+        raise Errors::ArrayMaxSizeError, "Cannot set max_size to nil." unless max_size
+        raise Errors::ArrayMaxSizeError, "The max_size can only be set once." if @max_size
+        raise Errors::ArrayMaxSizeError, "The size of Array #{size} exceeds max_size #{max_size}." if size > max_size
 
         @max_size = max_size
         self

data/lib/quant/series.rb

@@ -3,34 +3,47 @@
 module Quant
   # Ticks belong to the first series they're associated with always.
   # There are no provisions for series merging their ticks to one series!
-  # Indicators will be computed against the parent series of a list of ticks, so we
+  # {Indicators} will be computed against the parent series of a list of ticks, so we
   # can safely work with subsets of a series and indicators will compute just once.
   class Series
     include Enumerable
     extend Forwardable
 
-    def self.from_file(filename:, symbol:, interval:, folder: nil)
-      symbol = symbol.to_s.upcase
-      interval = Interval[interval]
-
-      filename = Rails.root.join("historical", folder, "#{symbol.upcase}.txt") if filename.nil?
+    # Loads a series of ticks when each line is a parsible JSON string that represents a tick.
+    # A {Quant::Ticks::TickSerializer} may be passed to convert the parsed JSON to {Quant::Ticks::Tick} object.
+    # @param filename [String] The filename to load the ticks from.
+    # @param symbol [String] The symbol of the series.
+    # @param interval [String] The interval of the series.
+    # @param serializer_class [Class] {Quant::Ticks::TickSerializer} class to use for the conversion.
+    def self.from_file(filename:, symbol:, interval:, serializer_class: nil)
       raise "File #{filename} does not exist" unless File.exist?(filename)
 
-      lines = File.read(filename).split("\n")
-      ticks = lines.map{ |line| Quant::Ticks::OHLC.from_json(line) }
-
-      from_ticks(symbol: symbol, interval: interval, ticks: ticks)
+      ticks = File.read(filename).split("\n").map{ |line| Oj.load(line) }
+      from_hash symbol: symbol, interval: interval, hash: ticks, serializer_class: serializer_class
     end
 
-    def self.from_json(symbol:, interval:, json:)
-      from_hash symbol: symbol, interval: interval, hash: Oj.load(json)
+    # Loads a series of ticks when the JSON string represents an array of ticks.
+    # A {Quant::Ticks::TickSerializer} may be passed to convert the parsed JSON to {Quant::Ticks::Tick} object.
+    # @param symbol [String] The symbol of the series.
+    # @param interval [String] The interval of the series.
+    # @param json [String] The JSON string to parse into ticks.
+    # @param serializer_class [Class] {Quant::Ticks::TickSerializer} class to use for the conversion.
+    def self.from_json(symbol:, interval:, json:, serializer_class: nil)
+      ticks = Oj.load(json)
+      from_hash symbol: symbol, interval: interval, hash: ticks, serializer_class: serializer_class
     end
 
-    def self.from_hash(symbol:, interval:, hash:)
-      ticks = hash.map { |tick_hash| Quant::Ticks::OHLC.from(tick_hash) }
-      from_ticks(symbol: symbol, interval: interval, ticks: ticks)
+    # Loads a series of ticks where the hash must be cast to an array of {Quant::Ticks::Tick} objects.
+    # @param symbol [String] The symbol of the series.
+    # @param interval [String] The interval of the series.
+    # @param hash [Array<Hash>] The array of hashes to convert to {Quant::Ticks::Tick} objects.
+    # @param serializer_class [Class] {Quant::Ticks::TickSerializer} class to use for the conversion.
+    def self.from_hash(symbol:, interval:, hash:, serializer_class: nil)
+      ticks = hash.map { |tick_hash| Quant::Ticks::OHLC.from(tick_hash, serializer_class: serializer_class) }
+      from_ticks symbol: symbol, interval: interval, ticks: ticks
     end
 
+    # Loads a series of ticks where the array represents an array of {Quant::Ticks::Tick} objects.
     def self.from_ticks(symbol:, interval:, ticks:)
       ticks = ticks.sort_by(&:close_timestamp)
 
@@ -43,7 +56,7 @@ module Quant
 
     def initialize(symbol:, interval:)
       @symbol = symbol
-      @interval = interval
+      @interval = Interval[interval]
       @ticks = []
     end
 
@@ -64,11 +77,8 @@ module Quant
     def_delegator :@ticks, :[]
     def_delegator :@ticks, :size
     def_delegator :@ticks, :each
-    def_delegator :@ticks, :select
     def_delegator :@ticks, :select!
-    def_delegator :@ticks, :reject
     def_delegator :@ticks, :reject!
-    def_delegator :@ticks, :first
     def_delegator :@ticks, :last
 
     def highest
@@ -92,7 +102,14 @@ module Quant
     end
 
     def <<(tick)
+      tick = Ticks::Spot.new(price: tick) if tick.is_a?(Numeric)
+      indicators << tick unless tick.series?
       @ticks << tick.assign_series(self)
+      self
+    end
+
+    def indicators
+      @indicators ||= IndicatorsSources.new(series: self)
     end
 
     def to_h

data/lib/quant/settings/indicators.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Quant
+  module Settings
+    # Indicator settings provide a way to configure the default settings for indicators.
+    # Many of the indicators are built in adaptive measuring of the dominant cycle and these settings
+    # provide a way to configure your choices for the indicators.  The default values come from various
+    # papers and books on the subject of technical analysis by John Ehlers where he variously suggests
+    # a minimum period of 8 or 10 and a max period of 48.
+    #
+    # The half period is the average of the max_period and min_period.
+    # The micro period comes from Ehler's writings on Swami charts and auto-correlation computations, which
+    # is a period of 3 bars.  It is useful enough in various indicators to be its own setting.
+    #
+    # The dominant cycle kind is the kind of dominant cycle to use in the indicator.  The default is +:settings+
+    # which means the dominant cycle is whatever the +max_period+ is set to.  It is not adaptive when configured
+    # this way.  The other kinds are adaptive and are computed from the series data.  The choices are:
+    # * +:settings+  - the max_period is the dominant cycle and is not adaptive
+    # * +:band_pass+ - The zero crossings of the band pass filter are used to compute the dominant cycle
+    # * +:auto_correlation_reversal+ - The dominant cycle is computed from the auto-correlation of the series.
+    # * +:homodyne+ - The dominant cycle is computed from the homodyne discriminator.
+    # * +:differential+ - The dominant cycle is computed from the differential discriminator.
+    # * +:phase_accumulator+ - The dominant cycle is computed from the phase accumulator.
+    #
+    # All of the above are adaptive and are computed from the series data and are described in John Ehlers' books
+    # and published papers.
+    #
+    # Pivot kinds are started as the classic pivot points and then expanded to include other kinds of bands that
+    # follow along with price action such as Donchian channels, Fibonacci bands, Bollinger bands, Keltner bands,
+    # etc.  The choices are as follows:
+    # * +:pivot+ - Classic pivot points
+    # * +:donchian+ - Donchian channels
+    # * +:fibbonacci+ - Fibonacci bands
+    # * +:woodie+ - Woodie's pivot points
+    # * +:classic+ - Classic pivot points
+    # * +:camarilla+ - Camarilla pivot points
+    # * +:demark+ - Demark pivot points
+    # * +:murrey+ - Murrey math pivot points
+    # * +:keltner+ - Keltner bands
+    # * +:bollinger+ - Bollinger bands
+    # * +:guppy+ - Guppy bands
+    # * +:atr+ - ATR bands
+    #
+    class Indicators
+      # Returns an instance of the settings for indicators configured with defaults derived from
+      # defined constants in the +Quant::Settings+ module.
+      def self.defaults
+        new
+      end
+
+      attr_accessor :max_period, :min_period, :half_period, :micro_period
+      attr_accessor :dominant_cycle_kind, :pivot_kind
+
+      def initialize(**settings)
+        @max_period = settings[:max_period] || Settings::MAX_PERIOD
+        @min_period = settings[:min_period] || Settings::MIN_PERIOD
+        @half_period = settings[:half_period] || compute_half_period
+        @micro_period = settings[:micro_period] || Settings::MICRO_PERIOD
+
+        @dominant_cycle_kind = settings[:dominant_cycle_kind] || Settings::DOMINANT_CYCLE_KINDS.first
+        @pivot_kind = settings[:pivot_kind] || Settings::PIVOT_KINDS.first
+      end
+
+      def apply_settings(**settings)
+        @max_period = settings.fetch(:max_period, @max_period)
+        @min_period = settings.fetch(:min_period, @min_period)
+        @half_period = settings.fetch(:half_period, @half_period || compute_half_period)
+        @micro_period = settings.fetch(:micro_period, @micro_period)
+        @dominant_cycle_kind = settings.fetch(:dominant_cycle_kind, @dominant_cycle_kind)
+        @pivot_kind = settings.fetch(:pivot_kind, @pivot_kind)
+      end
+
+      def compute_half_period
+        (max_period + min_period) / 2
+      end
+    end
+  end
+end

data/lib/quant/settings.rb

@@ -0,0 +1,48 @@
+module Quant
+  module Settings
+    MAX_PERIOD = 48
+    MIN_PERIOD = 10
+    HALF_PERIOD = (MAX_PERIOD + MIN_PERIOD) / 2
+    MICRO_PERIOD = 3
+
+    PIVOT_KINDS = %i(
+      pivot
+      donchian
+      fibbonacci
+      woodie
+      classic
+      camarilla
+      demark
+      murrey
+      keltner
+      bollinger
+      guppy
+      atr
+    ).freeze
+
+    DOMINANT_CYCLE_KINDS = %i(
+      settings
+      band_pass
+      auto_correlation_reversal
+      homodyne
+      differential
+      phase_accumulator
+    ).freeze
+
+    # ---- Risk Management Ratio Settings ----
+    #   Risk    Reward    Breakeven Win Rate %
+    #     50         1            98%
+    #     10         1            91%
+    #      5         1            83%
+    #      3         1            75%
+    #      2         1            67%
+    #      1         1            50%
+    #      1         2            33%
+    #      1         3            25%
+    #      1         5            17%
+    #      1        10             9%
+    #      1        50             2%
+    PROFIT_TARGET_PCT = 0.03
+    STOP_LOSS_PCT = 0.01
+  end
+end

data/lib/quant/ticks/ohlc.rb

@@ -4,14 +4,15 @@ require_relative "tick"
 
 module Quant
   module Ticks
-    # An +OHLC+ is a bar or candle for a point in time that has an open, high, low, and close price.
-    # It is the most common form of a +Tick+ and is usually used to representa time period such as a
-    # minute, hour, day, week, or month.  The +OHLC+ is used to represent the price action of an asset
-    # The interval of the +OHLC+ is the time period that the +OHLC+ represents, such has hourly, daily, weekly, etc.
+    # An {Quant::Ticks::OHLC} is a bar or candle for a point in time that has an open, high, low, and close price.
+    # It is the most common form of a {Quant::Ticks::Tick} and is usually used to representa time period such as a
+    # minute, hour, day, week, or month.  The {Quant::Ticks::OHLC} is used to represent the price action of an asset
+    # The interval of the {Quant::Ticks::OHLC} is the time period that the {Quant::Ticks::OHLC} represents,
+    # such has hourly, daily, weekly, etc.
     class OHLC < Tick
       include TimeMethods
 
-      attr_reader :interval, :series
+      attr_reader :series
       attr_reader :close_timestamp, :open_timestamp
       attr_reader :open_price, :high_price, :low_price, :close_price
       attr_reader :base_volume, :target_volume, :trades
@@ -26,8 +27,6 @@ module Quant
         low_price:,
         close_price:,
 
-        interval: nil,
-
         volume: nil,
         base_volume: nil,
         target_volume: nil,
@@ -44,8 +43,6 @@ module Quant
         @low_price = low_price.to_f
         @close_price = close_price.to_f
 
-        @interval = Interval[interval]
-
         @base_volume = (volume || base_volume).to_i
         @target_volume = (target_volume || @base_volume).to_i
         @trades = trades.to_i
@@ -131,7 +128,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} #{interval} ct=#{close_timestamp.iso8601} o=#{open_price} h=#{high_price} l=#{low_price} c=#{close_price} v=#{volume}>"
+        "#<#{self.class.name} ct=#{close_timestamp.iso8601} o=#{open_price} h=#{high_price} l=#{low_price} c=#{close_price} v=#{volume}>"
       end
     end
   end

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

@@ -16,13 +16,44 @@ module Quant
           from(hash, tick_class: tick_class)
         end
 
+        # Instantiates a tick from a +Hash+.  The hash keys are expected to be the same as the serialized keys.
+        #
+        # Serialized Keys:
+        # - ot: open timestamp
+        # - ct: close timestamp
+        # - o: open price
+        # - h: high price
+        # - l: low price
+        # - c: close price
+        # - bv: base volume
+        # - tv: target volume
+        # - t: trades
+        # - g: green
+        # - j: doji
+        def self.from(hash, tick_class:)
+          tick_class.new \
+            open_timestamp: hash["ot"],
+            close_timestamp: hash["ct"],
+
+            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
+
         # Returns a +Hash+ of the Spot tick's key properties
         #
         # Serialized Keys:
         #
         # - ot: open timestamp
         # - ct: close timestamp
-        # - iv: interval
         # - o: open price
         # - h: high price
         # - l: low price
@@ -37,12 +68,11 @@ module Quant
         # @return [Hash]
         # @example
         #  Quant::Ticks::Serializers::Tick.to_h(tick)
-        #  # => { "ot" => [Time], "ct" => [Time], "iv" => "1m", "o" => 1.0, "h" => 2.0,
+        #  # => { "ot" => [Time], "ct" => [Time], "o" => 1.0, "h" => 2.0,
         #  #      "l" => 0.5, "c" => 1.5, "bv" => 6.0, "tv" => 5.0, "t" => 1, "g" => true, "j" => true }
         def self.to_h(tick)
           { "ot" => tick.open_timestamp,
             "ct" => tick.close_timestamp,
-            "iv" => tick.interval.to_s,
 
             "o" => tick.open_price,
             "h" => tick.high_price,
@@ -56,25 +86,6 @@ module Quant
             "g" => tick.green,
             "j" => tick.doji }
         end
-
-        def self.from(hash, tick_class:)
-          tick_class.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
       end
     end
   end

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

@@ -21,7 +21,6 @@ module Quant
         # Serialized Keys:
         #
         # - ct: close timestamp
-        # - iv: interval
         # - cp: close price
         # - bv: base volume
         # - tv: target volume
@@ -31,11 +30,10 @@ module Quant
         # @return [Hash]
         # @example
         #  Quant::Ticks::Serializers::Tick.to_h(tick)
-        #  # => { "ct" => "2024-02-13 03:12:23 UTC", "cp" => 5.0, "iv" => "1d", "bv" => 0.0, "tv" => 0.0, "t" => 0 }
+        #  # => { "ct" => "2024-02-13 03:12:23 UTC", "cp" => 5.0, "bv" => 0.0, "tv" => 0.0, "t" => 0 }
         def self.to_h(tick)
           { "ct" => tick.close_timestamp,
             "cp" => tick.close_price,
-            "iv" => tick.interval.to_s,
             "bv" => tick.base_volume,
             "tv" => tick.target_volume,
             "t" => tick.trades }
@@ -45,7 +43,6 @@ module Quant
           tick_class.new(
             close_timestamp: hash["ct"],
             close_price: hash["cp"],
-            interval: hash["iv"],
             base_volume: hash["bv"],
             target_volume: hash["tv"],
             trades: hash["t"]

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

@@ -3,10 +3,10 @@
 module Quant
   module Ticks
     module Serializers
-      # The +Tick+ class serializes and deserializes +Tick+ objects to and from various formats.
-      # These classes are wired into the Tick classes and are used to convert +Tick+ objects to and from
+      # The {Quant::Ticks::Tick} class serializes and deserializes {Quant::Ticks::Tick} objects to and from various formats.
+      # These classes are wired into the Tick classes and are used to convert {Quant::Ticks::Tick} objects to and from
       # Ruby hashes, JSON strings, and CSV strings.  They're not typically used directly, but are extracted
-      # to make it easier to provide custom serialization and deserialization for +Tick+ objects not shipped
+      # to make it easier to provide custom serialization and deserialization for {Quant::Ticks::Tick} objects not shipped
       # with the library.
       # @abstract
       class Tick

data/lib/quant/ticks/spot.rb

@@ -4,7 +4,7 @@ require_relative "tick"
 
 module Quant
   module Ticks
-    # A +Spot+ is a single price point in time.  It is the most basic form of a +Tick+ and is usually used to represent
+    # 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
     # a continuously streaming tick that just has a single price point at a given point in time.
     # @example
     #   spot = Quant::Ticks::Spot.new(price: 100.0, timestamp: Time.now)
@@ -19,9 +19,9 @@ module Quant
     class Spot < Tick
       include TimeMethods
 
-      attr_reader :interval, :series
+      attr_reader :series
       attr_reader :close_timestamp, :open_timestamp
-      attr_reader :open_price, :high_price, :low_price, :close_price
+      attr_reader :close_price
       attr_reader :base_volume, :target_volume, :trades
 
       def initialize(
@@ -30,7 +30,6 @@ module Quant
         close_price: nil,
         close_timestamp: nil,
         volume: nil,
-        interval: nil,
         base_volume: nil,
         target_volume: nil,
         trades: nil
@@ -39,8 +38,6 @@ module Quant
 
         @close_price = (close_price || price).to_f
 
-        @interval = Interval[interval]
-
         @close_timestamp = extract_time(timestamp || close_timestamp || Quant.current_time)
         @open_timestamp = @close_timestamp
 
@@ -53,6 +50,9 @@ module Quant
 
       alias timestamp close_timestamp
       alias price close_price
+      alias high_price close_price
+      alias low_price close_price
+      alias open_price close_price
       alias oc2 close_price
       alias hl2 close_price
       alias hlc3 close_price
@@ -73,7 +73,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} #{interval} ct=#{close_timestamp} c=#{close_price.to_f} v=#{volume}>"
+        "#<#{self.class.name} ct=#{close_timestamp} c=#{close_price.to_f} v=#{volume}>"
       end
     end
   end