quantitative 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 266a7aa51d29b809224fa76091d26c52d58f6e42959aeeb4ca5ffb6376828773
-  data.tar.gz: 5b3ac92706338a77a098e5dee72f3ecf57f2c4032f946533225e6061d07082d5
+  metadata.gz: c9fa0c537499409fa9faa3fbca76beca44d37205c04c8de1c01b3e681985c2dc
+  data.tar.gz: 3916820207b47d2d19b79332e41329c35080ce1456c4a2ed751863ea220b5289
 SHA512:
-  metadata.gz: 624d6945e690d51b5afef5ebc7939eb3f444fd7d4d79a31e73df5a42e0f6c351f8d4ac451a455a657c96a07448a0c724ba1481156d2e859ca720c8994328547a
-  data.tar.gz: 51b9fd16424fe1fd1b48c72f350c89cfb9e26e0a082eb750ae864c436b51eeab2142c64744deee93b91aaafe119354f19a4159ecda84b066d75f1d242945a9a2
+  metadata.gz: e3bead0b7fc23208c62dd18bb8f701b684db20780ae793fab973ab07cea0740897026a66755a07b9857228e815bfc3679801171f2b5875f510a7c98781fd30cb
+  data.tar.gz: 8b07dbcbe1a86c507a31df950aef293ae018913964848a9298310fe71a7929924a5a7ced417cf5ef86e9282feb58bc9d16531bf6b77e0fa23cea28de7a761740

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quantitative (0.1.4)
+    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/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

@@ -1,7 +1,7 @@
 module Quant
   class Indicators
     class Indicator
-      # include Enumerable
+      include Enumerable
 
       # # include Mixins::TrendMethods
       # include Mixins::Trig
@@ -14,57 +14,103 @@ module Quant
       # include Mixins::Direction
       # include Mixins::Filters
 
-      # def inspect
-      #   "#<#{self.class.name} #{symbol} #{interval} #{points.size} points>"
-      # end
+      attr_reader :source, :series
 
-      # def compute
-      #   raise NotImplementedError
-      # end
+      def initialize(series:, source:)
+        @series = series
+        @source = source
+        @points = {}
+        series.each { |tick| self << tick }
+      end
 
-      # def [](index)
-      #   points[index]
-      # end
+      def ticks
+        @points.keys
+      end
 
-      # def after_append
-      #   # NoOp
-      # end
+      def values
+        @points.values
+      end
 
-      # def points_class
-      #   "Quant::Indicators::#{indicator_name}Point".constantize
-      # end
+      def size
+        @points.size
+      end
 
-      # def indicator_name
-      #   self.class.name.demodulize
-      # end
+      attr_reader :p0, :p1, :p2, :p3
+      attr_reader :t0, :t1, :t2, :t3
 
-      # def warmed_up?
-      #   true
-      # end
+      def <<(tick)
+        @t0 = tick
+        @p0 = points_class.new(tick: tick, source: source)
+        @points[tick] = @p0
 
-      # def initial_max_size
-      #   value = [series.size, series.max_size].max
-      #   value.zero? ? settings.initial_max_size : value
-      # end
+        @p1 = values[-2] || @p0
+        @p2 = values[-3] || @p1
+        @p3 = values[-4] || @p2
 
-      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
+        @t1 = ticks[-2] || @t0
+        @t2 = ticks[-3] || @t1
+        @t3 = ticks[-4] || @t2
 
-      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
+        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]) }
@@ -77,10 +123,6 @@ module Quant
       #   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.
@@ -103,13 +145,6 @@ module Quant
       #   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]

data/lib/quant/indicators/indicator_point.rb

@@ -3,33 +3,21 @@
 module Quant
   class Indicators
     class IndicatorPoint
-      extend Forwardable
+      include Quant::Attributes
 
-      attr_reader :tick, :source
+      attribute :tick
+      attribute :source, key: "src"
+      attribute :input, key: "in"
 
       def initialize(tick:, source:)
         @tick = tick
-        @source = @tick.send(source)
+        @source = source
+        @input = @tick.send(source)
+        initialize_data_points
       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)
+      def initialize_data_points
+        # No-Op - Override in subclass if needed.
       end
     end
   end

data/lib/quant/indicators/ma.rb

@@ -1,46 +1,38 @@
 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,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

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