quantitative 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19fe65cd5c50b0b503abaa0e7c5be3949a284cf5a2b537d79b9cbdd69448041d
-  data.tar.gz: fe03ed6b2ddef6609cee31547cd84c1eac948bb8d10efb8c24c316673c693a62
+  metadata.gz: 266a7aa51d29b809224fa76091d26c52d58f6e42959aeeb4ca5ffb6376828773
+  data.tar.gz: 5b3ac92706338a77a098e5dee72f3ecf57f2c4032f946533225e6061d07082d5
 SHA512:
-  metadata.gz: 9ce1d965a8e68f6fae76143dfc619ed98c8a5af559e9f26c67dd7685e60bf9b4cfa3ecf5f43908f01597862cb6d6389cebd40cf5897afed560a9e54ed79ea91e
-  data.tar.gz: ee8527e43aa4670175d20a20c6037af11227071ff0fe738344c4b9b91d2391335d210a9e5b305153e78edc75ca9acb802b56b2502223107a84366ae40ba55b7f
+  metadata.gz: 624d6945e690d51b5afef5ebc7939eb3f444fd7d4d79a31e73df5a42e0f6c351f8d4ac451a455a657c96a07448a0c724ba1481156d2e859ca720c8994328547a
+  data.tar.gz: 51b9fd16424fe1fd1b48c72f350c89cfb9e26e0a082eb750ae864c436b51eeab2142c64744deee93b91aaafe119354f19a4159ecda84b066d75f1d242945a9a2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.1.2)
+    quantitative (0.1.4)
       oj (~> 3.10)
 
 GEM

data/lib/quant/config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Quant
+  module Config
+    class Config
+      attr_reader :indicators
+
+      def initialize
+        @indicators = Settings::Indicators.defaults
+      end
+
+      def apply_indicator_settings(**settings)
+        @indicators.apply_settings(**settings)
+      end
+    end
+
+    def self.config
+      @config ||= Config.new
+    end
+  end
+
+  module_function
+
+  def config
+    Config.config
+  end
+
+  def configure_indicators(**settings)
+    config.apply_indicator_settings(**settings)
+    yield config.indicators if block_given?
+  end
+end

data/lib/quant/errors.rb

@@ -5,4 +5,5 @@ module Quant
   class InvalidInterval < Error; end
   class InvalidResolution < Error; end
   class ArrayMaxSizeError < Error; end
+  class SecurityClassError < Error; end
 end

data/lib/quant/indicators/indicator.rb

@@ -0,0 +1,136 @@
+module Quant
+  class Indicators
+    class Indicator
+      # include Enumerable
+
+      # # include Mixins::TrendMethods
+      # include Mixins::Trig
+      # include Mixins::WeightedAverage
+      # include Mixins::HilbertTransform
+      # include Mixins::SuperSmoother
+      # include Mixins::Stochastic
+      # include Mixins::FisherTransform
+      # include Mixins::HighPassFilter
+      # include Mixins::Direction
+      # include Mixins::Filters
+
+      # def inspect
+      #   "#<#{self.class.name} #{symbol} #{interval} #{points.size} points>"
+      # end
+
+      # def compute
+      #   raise NotImplementedError
+      # end
+
+      # def [](index)
+      #   points[index]
+      # end
+
+      # def after_append
+      #   # NoOp
+      # end
+
+      # def points_class
+      #   "Quant::Indicators::#{indicator_name}Point".constantize
+      # end
+
+      # def indicator_name
+      #   self.class.name.demodulize
+      # end
+
+      # def warmed_up?
+      #   true
+      # end
+
+      # def initial_max_size
+      #   value = [series.size, series.max_size].max
+      #   value.zero? ? settings.initial_max_size : value
+      # end
+
+      attr_reader :series #, :settings, :max_size, :points, :dc_period
+      # delegate :p0, :p1, :p2, :p3, :prev, :iteration, to: :points
+      # delegate :each, :size, :[], :last, :first, to: :points
+      # delegate :oc2, :high_price, :low_price, :open_price, :close_price, :volume, to: :p0
+
+      def initialize(series:) # settings: Settings::Indicators.defaults, cloning: false)
+        @series = series
+        # @settings = settings
+        # @max_size = initial_max_size
+        # @points = Points.new(indicator: self)
+        # return if cloning
+
+        # after_initialization
+        # parent_series.each { |ohlc| append ohlc }
+        # @points_for_cache = {}
+        # @dc_period = nil
+      end
+
+      # def points_for(series:)
+      #   @points_for_cache[series] ||= self.class.new(series:, settings:, cloning: true).tap do |indicator|
+      #     series.ticks.each { |tick| indicator.points.push(tick.indicators[self]) }
+      #   end
+      # end
+
+      # # Ticks belong to the first series they're associated with always
+      # # NOTE: No provisions for series merging their ticks to one series!
+      # def parent_series
+      #   series.ticks.empty? ? series : series.ticks.first.series
+      # end
+
+      # def after_initialization
+      #   # NoOp
+      # end
+
+      # # Returns the last point of the current indicator rather than the entire series
+      # # This is used for indicators that depend on dominant cycle or other indicators
+      # # to compute their data points.
+      # def current_point
+      #   points.size - 1
+      # end
+
+      # def dominant_cycles
+      #   parent_series.indicators.dominant_cycles
+      # end
+
+      # # Override this method to change source of dominant cycle computation for an indicator
+      # def dominant_cycle_indicator
+      #   @dominant_cycle_indicator ||= dominant_cycles.band_pass
+      # end
+
+      # def ensure_not_dominant_cycler_indicator
+      #   return unless is_a? Quant::Indicators::DominantCycles::DominantCycle
+
+      #   raise 'Dominant Cycle Indicators cannot use the thing they compute!'
+      # end
+
+      # # Sets the dominant cycle period for the current indicator's point
+      # # @dc_period gets set before each #compute call.
+      # def update_dc_period
+      #   ensure_not_dominant_cycler_indicator
+      #   @dc_period = current_dominant_cycle.period
+      # end
+
+      # # Returns the dominant cycle point for the current indicator's point
+      # def current_dominant_cycle
+      #   dominant_cycle_indicator[current_point]
+      # end
+
+      # # Returns the atr point for the current indicator's point
+      # def atr_point
+      #   parent_series.indicators.atr[current_point]
+      # end
+
+      # # def dc_period
+      # #   dominant_cycle.period.round(0).to_i
+      # # end
+
+      # def <<(ohlc)
+      #   points.append(ohlc)
+      # end
+
+      # def append(ohlc)
+      #   points.append(ohlc)
+      # end
+    end
+  end
+end

data/lib/quant/indicators/indicator_point.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class IndicatorPoint
+      extend Forwardable
+
+      attr_reader :tick, :source
+
+      def initialize(tick:, source:)
+        @tick = tick
+        @source = @tick.send(source)
+      end
+
+      def volume
+        @tick.base_volume
+      end
+
+      def timestamp
+        @tick.close_timestamp
+      end
+
+      def initialize_data_points(indicator:)
+        # NoOp
+      end
+
+      def to_h
+        raise NotImplementedError
+      end
+
+      def to_json(*args)
+        Oj.dump(to_h, *args)
+      end
+    end
+  end
+end

data/lib/quant/indicators/ma.rb

@@ -0,0 +1,46 @@
+module Quant
+  class Indicators
+    class MaPoint < IndicatorPoint
+      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
+        @osc = nil
+      end
+    end
+
+    # Moving Averages
+    class Ma < Indicator
+      def self.indicator_key
+        "ma"
+      end
+
+      def alpha(period)
+        bars_to_alpha(period)
+      end
+
+      def min_period
+        settings.min_period
+      end
+
+      def period
+        settings.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.osc = p0.ss - p0.ema
+      end
+    end
+  end
+end

data/lib/quant/indicators.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Quant
+  # < IndicatorsAccessor
+  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/security.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "security_class"
+
+module Quant
+  # A +Security+ is a representation of a financial instrument such as a stock, option, future, or currency.
+  # It is used to represent the instrument that is being traded, analyzed, or managed.
+  # @example
+  #   security = Quant::Security.new(symbol: "AAPL", name: "Apple Inc.", security_class: :stock, exchange: "NASDAQ")
+  #   security.symbol # => "AAPL"
+  #   security.name # => "Apple Inc."
+  #   security.stock? # => true
+  #   security.option? # => false
+  #   security.future? # => false
+  #   security.currency? # => false
+  #   security.exchange # => "NASDAQ"
+  #   security.to_h # => { "s" => "AAPL", "n" => "Apple Inc.", "sc" => "stock", "x" => "NASDAQ" }
+  class Security
+    attr_reader :symbol, :name, :security_class, :id, :exchange, :source, :meta, :created_at, :updated_at
+
+    def initialize(
+      symbol:,
+      name: nil,
+      id: nil,
+      active: true,
+      tradeable: true,
+      exchange: nil,
+      source: nil,
+      security_class: nil,
+      created_at: Quant.current_time,
+      updated_at: Quant.current_time,
+      meta: {}
+    )
+      raise ArgumentError, "symbol is required" unless symbol
+
+      @symbol = symbol.to_s.upcase
+      @name = name
+      @id = id
+      @tradeable = tradeable
+      @active = active
+      @exchange = exchange
+      @source = source
+      @security_class = SecurityClass.new(security_class)
+      @created_at = created_at
+      @updated_at = updated_at
+      @meta = meta
+    end
+
+    def active?
+      !!@active
+    end
+
+    def tradeable?
+      !!@tradeable
+    end
+
+    SecurityClass::CLASSES.each do |class_name|
+      define_method("#{class_name}?") do
+        security_class == class_name
+      end
+    end
+
+    def to_h(full: false)
+      return { "s" => symbol } unless full
+
+      { "s" => symbol,
+        "n" => name,
+        "id" => id,
+        "t" => tradeable?,
+        "a" => active?,
+        "x" => exchange,
+        "sc" => security_class.to_s,
+        "src" => source.to_s }
+    end
+
+    def to_json(*args, full: false)
+      Oj.dump(to_h(full: full), *args)
+    end
+  end
+end

data/lib/quant/security_class.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Quant
+  # Stocks (Equities): Represent ownership in a company. Stockholders are entitled to a share
+  # of the company's profits and have voting rights at shareholder meetings.
+
+  # Bonds (Fixed-Income Securities): Debt instruments where an investor lends money to an entity
+  # (government or corporation) in exchange for periodic interest payments and the return of
+  #  the principal amount at maturity.
+
+  # Mutual Funds: Pooled funds managed by an investment company. Investors buy shares in the mutual
+  # fund, and the fund invests in a diversified portfolio of stocks, bonds, or other securities.
+
+  # Exchange-Traded Funds (ETFs): Similar to mutual funds but traded on stock exchanges.
+  # ETFs can track an index, commodity, bonds, or a basket of assets.
+
+  # Options: Derivative securities that give the holder the right (but not the obligation) to buy
+  # or sell an underlying asset at a predetermined price before or at expiration.
+
+  # Futures: Contracts that obligate the buyer to purchase or the seller to sell an
+  # asset at a predetermined future date and price.
+
+  # Real Estate Investment Trusts (REITs): Companies that own, operate, or finance income-generating
+  # real estate. Investors can buy shares in a REIT, which provides them with a share of the
+  # income produced by the real estate.
+
+  # Cryptocurrencies: Digital or virtual currencies that use cryptography for security and operate on
+  # decentralized networks, typically based on blockchain technology. Examples include Bitcoin, Ethereum, and Ripple.
+
+  # Preferred Stock: A type of stock that has priority over common stock in terms of dividend
+  # payments and asset distribution in the event of liquidation.
+
+  # Treasury Securities: Issued by the government to raise funds. Types include Treasury bills (T-bills),
+  # Treasury notes (T-notes), and Treasury bonds (T-bonds).
+
+  # Mortgage-Backed Securities (MBS): Securities that represent an ownership interest in a pool of mortgage loans.
+  # Investors receive payments based on the interest and principal of the underlying loans.
+
+  # Commodities: Physical goods such as gold, silver, oil, or agricultural products, traded on commodity exchanges.
+
+  # Foreign Exchange (Forex): The market where currencies are traded. Investors can buy and sell currencies to
+  # profit from changes in exchange rates.
+  class SecurityClass
+    CLASSES = %i(
+      bond
+      commodity
+      cryptocurrency
+      etf
+      forex
+      future
+      mbs
+      mutual_fund
+      option
+      preferred_stock
+      reit
+      stock
+      treasury_note
+    ).freeze
+
+    attr_reader :security_class
+
+    def initialize(name)
+      return if @security_class = from_standard(name)
+
+      @security_class = from_alternate(name.to_s.downcase.to_sym) unless name.nil?
+      raise_unknown_security_class_error(name) unless security_class
+    end
+
+    CLASSES.each do |class_name|
+      define_method("#{class_name}?") do
+        security_class == class_name
+      end
+    end
+
+    def raise_unknown_security_class_error(name)
+      raise SecurityClassError, "Unknown security class: #{name.inspect}"
+    end
+
+    def to_s
+      security_class.to_s
+    end
+
+    def to_h
+      { "sc" => security_class }
+    end
+
+    def to_json(*args)
+      Oj.dump(to_h, *args)
+    end
+
+    def ==(other)
+      case other
+      when String then from_alternate(other.to_sym) == security_class
+      when Symbol then from_alternate(other) == security_class
+      when SecurityClass then other.security_class == security_class
+      else
+        false
+      end
+    end
+
+    private
+
+    ALTERNATE_NAMES = {
+      us_equity: :stock,
+      crypto: :cryptocurrency,
+    }.freeze
+
+    def from_standard(name)
+      name if CLASSES.include?(name)
+    end
+
+    def from_alternate(alt_name)
+      from_standard(alt_name) || ALTERNATE_NAMES[alt_name]
+    end
+  end
+end

data/lib/quant/series.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+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
+  # 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?
+      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)
+    end
+
+    def self.from_json(symbol:, interval:, json:)
+      from_hash symbol: symbol, interval: interval, hash: Oj.load(json)
+    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)
+    end
+
+    def self.from_ticks(symbol:, interval:, ticks:)
+      ticks = ticks.sort_by(&:close_timestamp)
+
+      new(symbol: symbol, interval: interval).tap do |series|
+        ticks.each { |tick| series << tick }
+      end
+    end
+
+    attr_reader :symbol, :interval, :ticks
+
+    def initialize(symbol:, interval:)
+      @symbol = symbol
+      @interval = interval
+      @ticks = []
+    end
+
+    def limit_iterations(start_iteration, stop_iteration)
+      selected_ticks = ticks[start_iteration..stop_iteration]
+      return self if selected_ticks.size == ticks.size
+
+      self.class.from_ticks(symbol: symbol, interval: interval, ticks: selected_ticks)
+    end
+
+    def limit(period)
+      selected_ticks = ticks.select{ |tick| period.cover?(tick.close_timestamp) }
+      return self if selected_ticks.size == ticks.size
+
+      self.class.from_ticks(symbol: symbol, interval: interval, ticks: selected_ticks)
+    end
+
+    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
+      ticks.max_by(&:high_price)
+    end
+
+    def lowest
+      ticks.min_by(&:low_price)
+    end
+
+    def ==(other)
+      [symbol, interval, ticks] == [other.symbol, other.interval, other.ticks]
+    end
+
+    def dup
+      self.class.from_ticks(symbol: symbol, interval: interval, ticks: ticks)
+    end
+
+    def inspect
+      "#<#{self.class.name} symbol=#{symbol} interval=#{interval} ticks=#{ticks.size}>"
+    end
+
+    def <<(tick)
+      @ticks << tick.assign_series(self)
+    end
+
+    def to_h
+      { "symbol" => symbol,
+        "interval" => interval,
+        "ticks" => ticks.map(&:to_h) }
+    end
+
+    def to_json(*args)
+      Oj.dump(to_h, *args)
+    end
+  end
+end

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,6 +4,10 @@ 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.
     class OHLC < Tick
       include TimeMethods
 
@@ -67,6 +71,11 @@ module Quant
         [open_timestamp, close_timestamp] == [other.open_timestamp, other.close_timestamp]
       end
 
+      # Two OHLC ticks are equal if their interval, close_timestamp, and close_price are equal.
+      def ==(other)
+        [interval, close_timestamp, close_price] == [other.interval, other.close_timestamp, other.close_price]
+      end
+
       # Returns the percent daily price change from open_price to close_price, ranging from 0.0 to 1.0.
       # A positive value means the price increased, and a negative value means the price decreased.
       # A value of 0.0 means no change.
@@ -120,6 +129,10 @@ module Quant
 
         body_ratio < 0.025 && head_ratio > 1.0 && tail_ratio > 1.0
       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}>"
+      end
     end
   end
 end

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

@@ -3,7 +3,7 @@
 module Quant
   module Ticks
     module Serializers
-      class OHLC < Tick
+      module OHLC
         # Returns a +Quant::Ticks::Tick+ from a valid JSON +String+.
         # @param json [String]
         # @param tick_class [Quant::Ticks::Tick]

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

@@ -39,7 +39,7 @@ module Quant
           Oj.dump to_h(tick)
         end
 
-        # Returns a Ruby +Hash+ comprised of the tick's key properties.
+        # Returns a Ruby +Hash+ comprised of the key properties for the tick.
         # @param tick [Quant::Ticks::Tick]
         # @return [Hash]
         # @example

data/lib/quant/ticks/spot.rb

@@ -60,6 +60,7 @@ module Quant
       alias delta close_price
       alias volume base_volume
 
+      # Two ticks are equal if they have the same close price and close timestamp.
       def ==(other)
         [close_price, close_timestamp] == [other.close_price, other.close_timestamp]
       end
@@ -72,7 +73,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} cp=#{close_price.to_f} ct=#{close_timestamp.strftime("%Y-%m-%d")} iv=#{interval.to_s} v=#{volume}>"
+        "#<#{self.class.name} #{interval} ct=#{close_timestamp} c=#{close_price.to_f} v=#{volume}>"
       end
     end
   end

data/lib/quant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quant
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 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 ticks).each do |sub_folder|
+%w(refinements settings ticks indicators).each do |sub_folder|
   Dir.glob(File.join(quant_folder, sub_folder, "**/*.rb")).each { |fn| require fn }
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-13 00:00:00.000000000 Z
+date: 2024-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -44,7 +44,12 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/quant/config.rb
 - lib/quant/errors.rb
+- lib/quant/indicators.rb
+- lib/quant/indicators/indicator.rb
+- lib/quant/indicators/indicator_point.rb
+- lib/quant/indicators/ma.rb
 - lib/quant/interval.rb
 - lib/quant/mixins/direction.rb
 - lib/quant/mixins/filters.rb
@@ -56,7 +61,11 @@ files:
 - lib/quant/mixins/trig.rb
 - lib/quant/mixins/weighted_average.rb
 - lib/quant/refinements/array.rb
-- lib/quant/ticks/core.rb
+- lib/quant/security.rb
+- lib/quant/security_class.rb
+- lib/quant/series.rb
+- lib/quant/settings.rb
+- lib/quant/settings/indicators.rb
 - lib/quant/ticks/ohlc.rb
 - lib/quant/ticks/serializers/ohlc.rb
 - lib/quant/ticks/serializers/spot.rb
@@ -90,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Quantitative and statistical tools written for Ruby 3.x for trading and finance.

data/lib/quant/ticks/core.rb

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