quantitative 0.1.4 → 0.1.5

data/lib/quant/indicators_proxy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Quant
+  class IndicatorsProxy
+    attr_reader :series, :source, :indicators
+
+    def initialize(series:, source:)
+      @series = series
+      @source = source
+      @indicators = {}
+    end
+
+    def indicator(indicator_class)
+      indicators[indicator_class] ||= indicator_class.new(series: series, source: source)
+    end
+
+    def <<(tick)
+      indicators.each_value { |indicator| indicator << tick }
+    end
+
+    def ma; indicator(Indicators::Ma) end
+  end
+end

data/lib/quant/indicators_sources.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Quant
+  class IndicatorsSources
+    def initialize(series:)
+      @series = series
+      @indicator_sources = {}
+    end
+
+    def <<(tick)
+      @indicator_sources.each_value { |indicator| indicator << tick }
+    end
+
+    def oc2
+      @indicator_sources[:oc2] ||= IndicatorsProxy.new(series: @series, source: :oc2)
+    end
+  end
+end

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/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

data/lib/quant/ticks/tick.rb

@@ -2,12 +2,12 @@
 
 module Quant
   module Ticks
-    # +Tick+ is the abstract ancestor for all Ticks and holds the logic for interacting with series and indicators.
+    # {Quant::Ticks::Tick} is the abstract ancestor for all Ticks and holds the logic for interacting with series and indicators.
     # The public interface is devoid of properties around price, volume, and timestamp, etc.  Descendant classes
     # are responsible for defining the properties and how they are represented.
     #
-    # The +Tick+ class is designed to be immutable and is intended to be used as a value object.  This means that
-    # once a +Tick+ is created, it cannot be changed.  This is important for the integrity of the series and
+    # The {Quant::Ticks::Tick} class is designed to be immutable and is intended to be used as a value object.  This means that
+    # once a {Quant::Ticks::Tick} is created, it cannot be changed.  This is important for the integrity of the series and
     # indicators that depend on the ticks within the series.
     #
     # When a tick is added to a series, it is locked into the series and ownership cannot be changed.  This is important
@@ -17,7 +17,7 @@ module Quant
     #
     # Ticks can be serialized to and from Ruby Hash, JSON strings, and CSV strings.
     class Tick
-      # Returns a +Tick+ from a Ruby +Hash+.  The default serializer is used to generate the +Tick+.
+      # Returns a {Quant::Ticks::Tick} from a Ruby +Hash+.  The default serializer is used to generate the {Quant::Ticks::Tick}.
       # @param hash [Hash]
       # @param serializer_class [Class] The serializer class to use for the conversion.
       # @return [Quant::Ticks::Tick]
@@ -25,11 +25,12 @@ module Quant
       #   hash = { "timestamp" => "2018-01-01 12:00:00 UTC", "price" => 100.0, "volume" => 1000 }
       #   Quant::Ticks::Tick.from(hash)
       #   # => #<Quant::Ticks::Spot:0x00007f9e3b8b3e08 @timestamp=2018-01-01 12:00:00 UTC, @price=100.0, @volume=1000>
-      def self.from(hash, serializer_class: default_serializer_class)
+      def self.from(hash, serializer_class: nil)
+        serializer_class ||= default_serializer_class
         serializer_class.from(hash, tick_class: self)
       end
 
-      # Returns a +Tick+ from a JSON string.  The default serializer is used to generate the +Tick+.
+      # Returns a {Quant::Ticks::Tick} from a JSON string.  The default serializer is used to generate the {Quant::Ticks::Tick}.
       # @param json [String]
       # @param serializer_class [Class] The serializer class to use for the conversion.
       # @return [Quant::Ticks::Tick]
@@ -41,21 +42,33 @@ module Quant
         serializer_class.from_json(json, tick_class: self)
       end
 
-      attr_reader :series
+      attr_reader :series, :indicators
 
       def initialize
         # Set the series by appending to the series or calling #assign_series method
         @series = nil
+        @interval = nil
+        @indicators = {}
+      end
+
+      def interval
+        @series&.interval || Interval[nil]
       end
 
       # Ticks always belong to the first series they're assigned so we can easily spin off
       # sub-sets or new series with the same ticks while allowing each series to have
       # its own state and full control over the ticks within its series
       def assign_series(new_series)
-        assign_series!(new_series) if @series.nil?
+        assign_series!(new_series) unless series?
         self
       end
 
+      # Returns true if the tick is assigned to a series.  The first series a tick is assigned
+      # to is the series against which the indicators compute.
+      def series?
+        !!@series
+      end
+
       # Ticks always belong to the first series they're assigned so we can easily spin off
       # sub-sets or new series with the same ticks.  However, if you need to reassign the
       # series, you can use this method to force the change of series ownership.
@@ -63,7 +76,7 @@ module Quant
       # The series interval is also assigned to the tick if it is not already set.
       def assign_series!(new_series)
         @series = new_series
-        @interval = new_series.interval if @interval.nil?
+        @interval ||= new_series.interval
         self
       end
 

data/lib/quant/version.rb

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

data/lib/quantitative.rb

@@ -12,6 +12,6 @@ quant_folder = File.join(lib_folder, "quant")
 Dir.glob(File.join(quant_folder, "*.rb")).each { |fn| require fn }
 
 # require sub-folders and their sub-folders
-%w(refinements settings ticks indicators).each do |sub_folder|
+%w(refinements mixins settings ticks indicators).each do |sub_folder|
   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
 end