quantitative 0.1.4 → 0.1.6

data/lib/quant/indicators/ma.rb

@@ -1,46 +1,40 @@
+# frozen_string_literal: true
+
 module Quant
   class Indicators
     class MaPoint < IndicatorPoint
+      attribute :ss, key: "ss"
+      attribute :ema, key: "ema"
       attr_accessor :ss, :ema, :osc
 
-      def to_h
-        {
-          "ss" => ss,
-          "ema" => delta_phase,
-          "osc" => osc
-        }
-      end
-
-      def initialize_data_points(indicator:)
-        @ss = oc2
-        @ema = oc2
+      def initialize_data_points
+        @ss = input
+        @ema = input
         @osc = nil
       end
     end
 
     # Moving Averages
     class Ma < Indicator
-      def self.indicator_key
-        "ma"
-      end
+      include Quant::Mixins::Filters
 
       def alpha(period)
         bars_to_alpha(period)
       end
 
       def min_period
-        settings.min_period
+        8 # Quant.config.indicators.min_period
       end
 
-      def period
-        settings.max_period
+      def max_period
+        48 # Quant.config.indicators.max_period
       end
 
       def compute
-        p0.ss = super_smoother p0.oc2, :ss, min_period
-        p0.ema = alpha(period) * p0.oc2 + (1 - alpha(period)) * p1.ema
+        # p0.ss = super_smoother input, :ss, min_period
+        p0.ema = alpha(max_period) * input + (1 - alpha(max_period)) * p1.ema
         p0.osc = p0.ss - p0.ema
       end
     end
   end
-end
+end

data/lib/quant/indicators/ping.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    # A simple point used primarily to test the indicator system in unit tests.
+    # It has a simple computation that just sets the pong value to the input value
+    # and increments the compute_count by 1 each time compute is called.
+    # Sometimes you just gotta play ping pong to win.
+    class PingPoint < IndicatorPoint
+      attribute :pong
+      attribute :compute_count, default: 0
+    end
+
+    # A simple idicator used primarily to test the indicator system
+    class Ping < Indicator
+      def compute
+        p0.pong = input
+        p0.compute_count += 1
+      end
+    end
+  end
+end

data/lib/quant/indicators.rb

@@ -1,29 +1,7 @@
 # frozen_string_literal: true
 
 module Quant
-  # < IndicatorsAccessor
+  # TODO: build an Indicator registry so new indicators can be added and used outside those shipped with the library.
   class Indicators
-    # def atr;            indicator(Indicators::Atr) end
-    # def adx;            indicator(Indicators::Adx) end
-    # def cci;            indicator(Indicators::Cci) end
-    # def cdi;            indicator(Indicators::Cdi) end
-    # def decycler;       indicator(Indicators::Decycler) end
-    # def frema;          indicator(Indicators::Frema) end
-    # def hilo;           indicator(Indicators::HiLo) end
-    # def ma;             indicator(Indicators::Ma) end
-    # def mama;           indicator(Indicators::Mama) end
-    # def frama;          indicator(Indicators::Frama) end
-    # def mesa;           indicator(Indicators::Mesa) end
-    # def roofing;        indicator(Indicators::Roofing) end
-    # def rsi;            indicator(Indicators::Rsi) end
-    # def rrr;            indicator(Indicators::Rrr) end
-    # def rrsi;           indicator(Indicators::RocketRsi) end
-    # def samo;           indicator(Indicators::Samo) end
-    # def snr;            indicator(Indicators::Snr) end
-    # def ssf;            indicator(Indicators::Ssf) end
-    # def volume;         indicator(Indicators::VolumeSsf) end
-    # def vol;            indicator(Indicators::Vol) end
-    # def vrsi;           indicator(Indicators::VolumeRsi) end
-    # def weibull;        indicator(Indicators::Weibull) end
   end
 end

data/lib/quant/indicators_proxy.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Quant
+  # The {Quant::IndicatorsProxy} class is responsible for lazily loading indicators
+  # so that not all indicators are always engaged and computing their values.
+  # If the indicator is never accessed, it's never computed, saving valuable
+  # processing CPU cycles.
+  #
+  # Indicators are generally built around the concept of a source input value and
+  # that source is designated by the source parameter when instantiating the
+  # {Quant::IndicatorsProxy} class.
+  #
+  # By design, the {Quant::Indicator} class holds the {Quant::Ticks::Tick} instance
+  # alongside the indicator's computed values for that tick.
+  class IndicatorsProxy
+    attr_reader :series, :source, :indicators
+
+    def initialize(series:, source:)
+      @series = series
+      @source = source
+      @indicators = {}
+    end
+
+    # Instantiates the indicator class and stores it in the indicators hash.  Once
+    # prepared, the indicator becomes active and all ticks pushed into the series
+    # are sent to the indicator for processing.
+    def indicator(indicator_class)
+      indicators[indicator_class] ||= indicator_class.new(series: series, source: source)
+    end
+
+    # Adds the tick to all active indicators, triggering them to compute
+    # new values against the latest tick.
+    #
+    # NOTE:  Dominant cycle indicators must be computed first as many
+    # indicators are adaptive and require the dominant cycle period.
+    # The IndicatorsProxy class is not responsible for enforcing
+    # this order of events.
+    def <<(tick)
+      indicators.each_value { |indicator| indicator << tick }
+    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.
+    #
+    # 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.
+    #
+    # @param name [Symbol] The name of the method to define for accessing the indicator.
+    # @param indicator_class [Class] The class of the indicator to attach.
+    # @example
+    #   series.indicators.oc2.attach(name: :foo, indicator_class: Indicators::Foo)
+    def attach(name:, indicator_class:)
+      define_singleton_method(name) { indicator(indicator_class) }
+    end
+
+    def ma; indicator(Indicators::Ma) end
+    def ping; indicator(Indicators::Ping) 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/mixins/moving_averages.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Quant
+  module Mixins
+    module MovingAverages
+      using Quant
+
+      # Computes the Weighted Moving Average (WMA) of the series, using the four most recent data points.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @return [Float] the weighted average of the series.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   p0.wma = weighted_average(:close_price)
+      def weighted_moving_average(source)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        [4.0 * p0.send(source),
+         3.0 * p1.send(source),
+         2.0 * p2.send(source),
+               p3.send(source)].sum / 10.0
+      end
+      alias wma weighted_moving_average
+
+      # Computes the Weighted Moving Average (WMA) of the series, using the seven most recent data points.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @return [Float] the weighted average of the series.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   p0.wma = weighted_average(:close_price)
+      def extended_weighted_moving_average(source)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        [7.0 * p0.send(source),
+         6.0 * p1.send(source),
+         5.0 * p2.send(source),
+         4.0 * p3.send(source),
+         3.0 * p(4).send(source),
+         2.0 * p(5).send(source),
+               p(6).send(source)].sum / 28.0
+      end
+      alias ewma extended_weighted_moving_average
+
+      # Computes the Simple Moving Average (SMA) of the given period.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @param period [Integer] the number of elements to compute the SMA over.
+      # @return [Float] the simple moving average of the period.
+      def simple_moving_average(source, period:)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+
+        values.last(period).map { |value| value.send(source) }.mean
+      end
+      alias sma simple_moving_average
+
+      # Computes the Exponential Moving Average (EMA) of the given period.
+      #
+      # The EMA computation is optimized to compute using just the last two
+      # indicator data points and is expected to be called in each indicator's
+      # `#compute` method for each iteration on the series.
+      #
+      # @param source [Symbol] the source of the data points to be used in the calculation.
+      # @param previous [Symbol] the previous EMA value.
+      # @param period [Integer] the number of elements to compute the EMA over.
+      # @return [Float] the exponential moving average of the period.
+      # @raise [ArgumentError] if the source is not a Symbol.
+      # @example
+      #   def compute
+      #     p0.ema = exponential_moving_average(:close_price, period: 3)
+      #   end
+      #
+      #   def compute
+      #     p0.ema = exponential_moving_average(:close_price, previous: :ema, period: 3)
+      #   end
+      def exponential_moving_average(source, previous: :ema, period:)
+        raise ArgumentError, "source must be a Symbol" unless source.is_a?(Symbol)
+        raise ArgumentError, "previous must be a Symbol" unless previous.is_a?(Symbol)
+
+        alpha = 2.0 / (period + 1)
+        p0.send(source) * alpha + p1.send(previous) * (1.0 - alpha)
+      end
+      alias ema exponential_moving_average
+    end
+  end
+end

data/lib/quant/mixins/super_smoother.rb

@@ -66,9 +66,8 @@ module Quant
         p3 = points[-4] || p2
 
         v0 = source.is_a?(Symbol) ? p0.send(source) : source
-        return v0 if [p0 == p3]
+        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

data/lib/quant/refinements/array.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 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.
     #
@@ -32,7 +34,6 @@ module Quant
     #   The refined behavior generally only exists within the library's scope, but if you call `using Quant` in your
     #   own code, you may encounter the changed behavior unexpectedly.
     module Array
-
       # Overrides the standard +<<+ method to track the +maximum+ and +minimum+ values
       # while also respecting the +max_size+ setting.
       def <<(value)
@@ -67,7 +68,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 +90,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
@@ -108,7 +110,7 @@ module Quant
         subset = last(n)
         return 0.0 if subset.empty?
 
-        sum = subset.sum / subset.size.to_f
+        subset.sum / subset.size.to_f
       end
 
       # Computes the Exponential Moving Average (EMA) of the array.  When +n+ is specified,
@@ -174,7 +176,7 @@ module Quant
       # @param n [Integer] the number of elements to compute the Standard Deviation over.
       # @return [Float]
       def stddev(reference_value, n: size)
-        variance(reference_value, n: n) ** 0.5
+        variance(reference_value, n: n)**0.5
       end
 
       def variance(reference_value, n: size)

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.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Quant
   module Settings
     MAX_PERIOD = 48

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
@@ -92,7 +89,7 @@ module Quant
       # This method is useful for comparing the volatility of different assets.
       # @return [Float]
       def daily_price_change_ratio
-        @price_change ||= ((open_price - close_price) / oc2).abs
+        @daily_price_change_ratio ||= ((open_price - close_price) / oc2).abs
       end
 
       # Set the #green? property to true when the close_price is greater than or equal to the open_price.
@@ -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