quantitative 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bfe61d98618c7cfb83052426689976be38c45e83fce9217a74a4f0392897b60
-  data.tar.gz: 061d9a0179eb913c5f5f5d9f1016998c2cbc0d65da9a774620a3b591f18a1f49
+  metadata.gz: c9fa0c537499409fa9faa3fbca76beca44d37205c04c8de1c01b3e681985c2dc
+  data.tar.gz: 3916820207b47d2d19b79332e41329c35080ce1456c4a2ed751863ea220b5289
 SHA512:
-  metadata.gz: 4154a9e589bcffd15b3415ace9c1ccc6b8d29ba5ecc0180e48259c649a746a157f58bd89aeabad4ffc4ac5edefe6f1892c94adcd001ba5d1f039a5bb46a8a9d0
-  data.tar.gz: 7ac2b4661e6c4b0e02fda9389f73b8d007b92e754e8b4fa821bb55dca1d085dfd7e2e3eb6608d520a2e2e6008eb837aa75e7c07c05addc28af577b92fe98f8c3
+  metadata.gz: e3bead0b7fc23208c62dd18bb8f701b684db20780ae793fab973ab07cea0740897026a66755a07b9857228e815bfc3679801171f2b5875f510a7c98781fd30cb
+  data.tar.gz: 8b07dbcbe1a86c507a31df950aef293ae018913964848a9298310fe71a7929924a5a7ced417cf5ef86e9282feb58bc9d16531bf6b77e0fa23cea28de7a761740

data/Gemfile.lock

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

data/lib/quant/asset.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "asset_class"
+
+module Quant
+  # A {Quant::Asset} 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.
+  #
+  # Not all data sources have a rich set of attributes for their assets or securities.  The {Quant::Asset} is designed
+  # to be flexible and to support a wide variety of data sources and use-cases.  The most common use-cases are supported
+  # while allowing for additional attributes to be added via the +meta+ attribute, which is tyipically just a Hash,
+  # but can be any object that can hold useful information about the asset such as currency formatting, precision, etc.
+  # @example
+  #   asset = Quant::Asset.new(symbol: "AAPL", name: "Apple Inc.", asset_class: :stock, exchange: "NASDAQ")
+  #   asset.symbol # => "AAPL"
+  #   asset.name # => "Apple Inc."
+  #   asset.stock? # => true
+  #   asset.option? # => false
+  #   asset.future? # => false
+  #   asset.currency? # => false
+  #   asset.exchange # => "NASDAQ"
+  #
+  #   # Can serialize two ways:
+  #   asset.to_h # => { "s" => "AAPL" }
+  #   asset.to_h(full: true) # => { "s" => "AAPL", "n" => "Apple Inc.", "sc" => "stock", "x" => "NASDAQ" }
+  class Asset
+    attr_reader :symbol, :name, :asset_class, :id, :exchange, :source, :meta, :created_at, :updated_at
+
+    def initialize(
+      symbol:,
+      name: nil,
+      id: nil,
+      active: true,
+      tradeable: true,
+      exchange: nil,
+      source: nil,
+      asset_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
+      @asset_class = AssetClass.new(asset_class)
+      @created_at = created_at
+      @updated_at = updated_at
+      @meta = meta
+    end
+
+    def active?
+      !!@active
+    end
+
+    def tradeable?
+      !!@tradeable
+    end
+
+    AssetClass::CLASSES.each do |class_name|
+      define_method("#{class_name}?") do
+        asset_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" => asset_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 → asset_class.rb}

@@ -24,7 +24,7 @@ module Quant
   # 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
+  # Cryptocurrencies: Digital or virtual currencies that use cryptography for asset 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
@@ -40,7 +40,7 @@ module Quant
 
   # Foreign Exchange (Forex): The market where currencies are traded. Investors can buy and sell currencies to
   # profit from changes in exchange rates.
-  class SecurityClass
+  class AssetClass
     CLASSES = %i(
       bond
       commodity
@@ -57,31 +57,31 @@ module Quant
       treasury_note
     ).freeze
 
-    attr_reader :security_class
+    attr_reader :asset_class
 
     def initialize(name)
-      return if @security_class = from_standard(name)
+      return if @asset_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
+      @asset_class = from_alternate(name.to_s.downcase.to_sym) unless name.nil?
+      raise_unknown_asset_class_error(name) unless asset_class
     end
 
     CLASSES.each do |class_name|
       define_method("#{class_name}?") do
-        security_class == class_name
+        asset_class == class_name
       end
     end
 
-    def raise_unknown_security_class_error(name)
-      raise SecurityClassError, "Unknown security class: #{name.inspect}"
+    def raise_unknown_asset_class_error(name)
+      raise Errors::AssetClassError, "Unknown asset class: #{name.inspect}"
     end
 
     def to_s
-      security_class.to_s
+      asset_class.to_s
     end
 
     def to_h
-      { "sc" => security_class }
+      { "sc" => asset_class }
     end
 
     def to_json(*args)
@@ -90,9 +90,9 @@ module Quant
 
     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
+      when String then from_alternate(other.to_sym) == asset_class
+      when Symbol then from_alternate(other) == asset_class
+      when AssetClass then other.asset_class == asset_class
       else
         false
       end

data/lib/quant/attributes.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Quant
+  module Attributes
+    # Tracks all defined attributes, allowing child classes to inherit their parent's attributes.
+    # The registry key is the class registering an attrbritute and is itself a hash of the attribute name
+    # and the attribute's key and default value.
+    # Internal use only.
+    #
+    # @example
+    #   { Quant::Indicators::IndicatorPoint => {
+    #       tick: { key: nil, default: nil },
+    #       source: { key: "src", default: nil },
+    #       input: { key: "in", default: nil }
+    #     },
+    #     Quant::Indicators::PingPoint => {
+    #       pong: { key: nil, default: nil },
+    #       compute_count: { key: nil, default: 0 }
+    #     }
+    #   }
+    # @return [Hash] The registry of all defined attributes.
+    def self.registry
+      @registry ||= {}
+    end
+
+    # Removes the given class from the registry. Useful for testing.
+    def self.deregister(klass)
+      registry.delete(klass)
+    end
+
+    # Registers an attribute for a class in the registry.
+    # Internal use only.
+    #
+    # @param klass [Class] The class registering the attribute
+    # @param name [Symbol] The name of the attribute
+    # @param key [String] The key to use when serializing the attribute
+    # @param default [Object] The default value for the attribute
+    def self.register(klass, name, key, default)
+      # Disallow redefining or replacing a key as it is easy to miss the overwrite
+      # and leads to serialization surprises.
+      if key && registry.values.flat_map(&:values).map{ |entry| entry[:key] }.include?(key)
+        raise Errors::DuplicateAttributesKeyError, "Attribute Key #{key} already defined!"
+      end
+
+      registry[klass] ||= {}
+      registry[klass][name] = { key: key, default: default }
+    end
+
+    module InstanceMethods
+      def initialize(...)
+        initialize_attributes
+        super(...)
+      end
+
+      # Iterates over all defined attributes in a child => parent hierarchy,
+      # and yields the name and entry for each.
+      def each_attribute(&block)
+        klass = self.class
+        loop do
+          attributes = Attributes.registry[klass]
+          break if attributes.nil?
+
+          attributes.each{ |name, entry| block.call(name, entry) }
+          klass = klass.superclass
+        end
+      end
+
+      # Initializes the defined attributes with default values and
+      # defines accessor methods for each attribute.
+      # If a child class redefines a parent's attribute, the child's
+      # definition will be used.
+      def initialize_attributes
+        each_attribute do |name, entry|
+          # use the child's definition, skipping the parent's
+          next if respond_to?(name)
+
+          ivar_name = "@#{name}"
+          instance_variable_set(ivar_name, entry[:default])
+          define_singleton_method(name) { instance_variable_get(ivar_name) }
+          define_singleton_method("#{name}=") { |value| instance_variable_set(ivar_name, value) }
+        end
+      end
+
+      # Serializes keys that have been defined as serializeable attributes
+      # Key values that are nil are removed from the hash
+      # @return [Hash] The serialized attributes as a Ruby Hash.
+      def to_h
+        {}.tap do |key_values|
+          each_attribute do |name, entry|
+            next unless entry[:key]
+
+            ivar_name = "@#{name}"
+            value = instance_variable_get(ivar_name)
+
+            key_values[entry[:key]] = value if value
+          end
+        end
+      end
+
+      # Serializes keys that have been defined as serializeable attributes
+      # Key values that are nil are removed from the hash
+      # @return [String] The serialized attributes as a JSON string.
+      def to_json(*args)
+        Oj.dump(to_h, *args)
+      end
+    end
+
+    module ClassMethods
+      # Define an +attribute+ for the class that can optionally be serialized.
+      # Works much like an attr_accessor does, but also manages serialization for
+      # #to_h and #to_json methods.
+      #
+      # An +attribute+ will result in a same-named instance on the class when
+      # it is instantiated and it will set a default value if one is provided.
+      #
+      # @param name [Symbol] The name of the attribute and it's accessor methods
+      # @param key [String] The key to use when serializing the attribute
+      # @param default [Object] The default value for the attribute
+      #
+      # @examples
+      #   attribute :tick                 # will not serialize to a key
+      #   attribute :source, key: "src"   # serializes to "src" key
+      #   attribute :input, key: "in"     # serializes to "in" key
+      def attribute(name, key: nil, default: nil)
+        Attributes.register(self, name, key, default)
+      end
+    end
+
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+      base.prepend(InstanceMethods)
+    end
+  end
+end

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

@@ -1,9 +1,34 @@
 # frozen_string_literal: true
 
 module Quant
-  class Error < StandardError; end
-  class InvalidInterval < Error; end
-  class InvalidResolution < Error; end
-  class ArrayMaxSizeError < Error; end
-  class SecurityClassError < Error; end
+  module Errors
+    # {Error} is the base class for all errors in the Quant gem.
+    # It is a subclass of the Ruby {StandardError}.
+    class Error < StandardError; end
+
+    # {InvalidInterval} is raised when attempting to instantiate an
+    # {Quant::Interval} with an invalid value.
+    class InvalidInterval < Error; end
+
+    # {InvalidResolution} is raised when attempting to instantiate
+    # an {Quant::Resolution} with a resolution value that has not been defined.
+    class InvalidResolution < Error; end
+
+    # {ArrayMaxSizeError} is raised when attempting to set the +max_size+ on
+    # the refined {Array} class to an invalid value or when attempting to
+    # redefine the +max_size+ on the refined {Array} class.
+    class ArrayMaxSizeError < Error; end
+
+    # {AssetClassError} is raised when attempting to instantiate a
+    # {Quant::Asset} with an attribute that is not a valid {Quant::Asset} attribute.
+    class AssetClassError < Error; end
+
+    # {DuplicateAttributesKeyError} is raised when attempting to define an
+    # attribute with a key that has already been defined.
+    class DuplicateAttributesKeyError < Error; end
+
+    # {DuplicateAttributesNameError} is raised when attempting to define an
+    # attribute with a name that has already been defined.
+    class DuplicateAttributesNameError < Error; end
+  end
 end

data/lib/quant/indicators/indicator.rb

@@ -0,0 +1,171 @@
+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
+
+      attr_reader :source, :series
+
+      def initialize(series:, source:)
+        @series = series
+        @source = source
+        @points = {}
+        series.each { |tick| self << tick }
+      end
+
+      def ticks
+        @points.keys
+      end
+
+      def values
+        @points.values
+      end
+
+      def size
+        @points.size
+      end
+
+      attr_reader :p0, :p1, :p2, :p3
+      attr_reader :t0, :t1, :t2, :t3
+
+      def <<(tick)
+        @t0 = tick
+        @p0 = points_class.new(tick: tick, source: source)
+        @points[tick] = @p0
+
+        @p1 = values[-2] || @p0
+        @p2 = values[-3] || @p1
+        @p3 = values[-4] || @p2
+
+        @t1 = ticks[-2] || @t0
+        @t2 = ticks[-3] || @t1
+        @t3 = ticks[-4] || @t2
+
+        compute
+      end
+
+      def each(&block)
+        @points.each_value(&block)
+      end
+
+      def inspect
+        "#<#{self.class.name} symbol=#{series.symbol} source=#{source} #{points.size} ticks>"
+      end
+
+      def compute
+        raise NotImplementedError
+      end
+
+      def indicator_name
+        self.class.name.split("::").last
+      end
+
+      def points_class
+        Object.const_get "Quant::Indicators::#{indicator_name}Point"
+      end
+
+      # p(0) => values[-1]
+      # p(1) => values[-2]
+      # p(2) => values[-3]
+      # p(3) => values[-4]
+      def p(offset)
+        raise ArgumentError, "offset must be a positive value" if offset < 0
+
+        index = offset + 1
+        values[[-index, -size].max]
+      end
+
+      # t(0) => ticks[-1]
+      # t(1) => ticks[-2]
+      # t(2) => ticks[-3]
+      # t(3) => ticks[-4]
+      def t(offset)
+        raise ArgumentError, "offset must be a positive value" if offset < 0
+
+        index = offset + 1
+        ticks[[-index, -size].max]
+      end
+
+      # The input is the value derived from the source for the indicator
+      # for the current tick.
+      # For example, if the source is :oc2, then the input is the
+      # value of the current tick's (open + close) / 2
+      # @return [Numeric]
+      def input
+        t0.send(source)
+      end
+
+      # def warmed_up?
+      #   true
+      # end
+
+      # attr_reader :dc_period
+
+      # 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
+
+      # # 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
+
+      # # 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,24 @@
+# frozen_string_literal: true
+
+module Quant
+  class Indicators
+    class IndicatorPoint
+      include Quant::Attributes
+
+      attribute :tick
+      attribute :source, key: "src"
+      attribute :input, key: "in"
+
+      def initialize(tick:, source:)
+        @tick = tick
+        @source = source
+        @input = @tick.send(source)
+        initialize_data_points
+      end
+
+      def initialize_data_points
+        # No-Op - Override in subclass if needed.
+      end
+    end
+  end
+end

data/lib/quant/indicators/ma.rb

@@ -0,0 +1,38 @@
+module Quant
+  class Indicators
+    class MaPoint < IndicatorPoint
+      attribute :ss, key: "ss"
+      attribute :ema, key: "ema"
+      attr_accessor :ss, :ema, :osc
+
+      def initialize_data_points
+        @ss = input
+        @ema = input
+        @osc = nil
+      end
+    end
+
+    # Moving Averages
+    class Ma < Indicator
+      include Quant::Mixins::Filters
+
+      def alpha(period)
+        bars_to_alpha(period)
+      end
+
+      def min_period
+        8 # Quant.config.indicators.min_period
+      end
+
+      def max_period
+        48 # Quant.config.indicators.max_period
+      end
+
+      def compute
+        # 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

data/lib/quant/indicators/ping.rb

@@ -0,0 +1,16 @@
+module Quant
+  class Indicators
+    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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Quant
+  # TODO: build an Indicator registry so new indicators can be added and used outside those shipped with the library.
+  class Indicators
+  end
+end

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