quantitative 0.1.4 → 0.1.6

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

@@ -16,13 +16,44 @@ module Quant
           from(hash, tick_class: tick_class)
         end
 
+        # Instantiates a tick from a +Hash+.  The hash keys are expected to be the same as the serialized keys.
+        #
+        # Serialized Keys:
+        # - ot: open timestamp
+        # - ct: close timestamp
+        # - o: open price
+        # - h: high price
+        # - l: low price
+        # - c: close price
+        # - bv: base volume
+        # - tv: target volume
+        # - t: trades
+        # - g: green
+        # - j: doji
+        def self.from(hash, tick_class:)
+          tick_class.new \
+            open_timestamp: hash["ot"],
+            close_timestamp: hash["ct"],
+
+            open_price: hash["o"],
+            high_price: hash["h"],
+            low_price: hash["l"],
+            close_price: hash["c"],
+
+            base_volume: hash["bv"],
+            target_volume: hash["tv"],
+
+            trades: hash["t"],
+            green: hash["g"],
+            doji: hash["j"]
+        end
+
         # Returns a +Hash+ of the Spot tick's key properties
         #
         # Serialized Keys:
         #
         # - ot: open timestamp
         # - ct: close timestamp
-        # - iv: interval
         # - o: open price
         # - h: high price
         # - l: low price
@@ -37,12 +68,11 @@ module Quant
         # @return [Hash]
         # @example
         #  Quant::Ticks::Serializers::Tick.to_h(tick)
-        #  # => { "ot" => [Time], "ct" => [Time], "iv" => "1m", "o" => 1.0, "h" => 2.0,
+        #  # => { "ot" => [Time], "ct" => [Time], "o" => 1.0, "h" => 2.0,
         #  #      "l" => 0.5, "c" => 1.5, "bv" => 6.0, "tv" => 5.0, "t" => 1, "g" => true, "j" => true }
         def self.to_h(tick)
           { "ot" => tick.open_timestamp,
             "ct" => tick.close_timestamp,
-            "iv" => tick.interval.to_s,
 
             "o" => tick.open_price,
             "h" => tick.high_price,
@@ -56,25 +86,6 @@ module Quant
             "g" => tick.green,
             "j" => tick.doji }
         end
-
-        def self.from(hash, tick_class:)
-          tick_class.new \
-            open_timestamp: hash["ot"],
-            close_timestamp: hash["ct"],
-            interval: hash["iv"],
-
-            open_price: hash["o"],
-            high_price: hash["h"],
-            low_price: hash["l"],
-            close_price: hash["c"],
-
-            base_volume: hash["bv"],
-            target_volume: hash["tv"],
-
-            trades: hash["t"],
-            green: hash["g"],
-            doji: hash["j"]
-        end
       end
     end
   end

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

@@ -21,7 +21,6 @@ module Quant
         # Serialized Keys:
         #
         # - ct: close timestamp
-        # - iv: interval
         # - cp: close price
         # - bv: base volume
         # - tv: target volume
@@ -31,11 +30,10 @@ module Quant
         # @return [Hash]
         # @example
         #  Quant::Ticks::Serializers::Tick.to_h(tick)
-        #  # => { "ct" => "2024-02-13 03:12:23 UTC", "cp" => 5.0, "iv" => "1d", "bv" => 0.0, "tv" => 0.0, "t" => 0 }
+        #  # => { "ct" => "2024-02-13 03:12:23 UTC", "cp" => 5.0, "bv" => 0.0, "tv" => 0.0, "t" => 0 }
         def self.to_h(tick)
           { "ct" => tick.close_timestamp,
             "cp" => tick.close_price,
-            "iv" => tick.interval.to_s,
             "bv" => tick.base_volume,
             "tv" => tick.target_volume,
             "t" => tick.trades }
@@ -45,7 +43,6 @@ module Quant
           tick_class.new(
             close_timestamp: hash["ct"],
             close_price: hash["cp"],
-            interval: hash["iv"],
             base_volume: hash["bv"],
             target_volume: hash["tv"],
             trades: hash["t"]

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

@@ -3,10 +3,10 @@
 module Quant
   module Ticks
     module Serializers
-      # The +Tick+ class serializes and deserializes +Tick+ objects to and from various formats.
-      # These classes are wired into the Tick classes and are used to convert +Tick+ objects to and from
+      # The {Quant::Ticks::Tick} class serializes and deserializes {Quant::Ticks::Tick} objects to and from various formats.
+      # These classes are wired into the Tick classes and are used to convert {Quant::Ticks::Tick} objects to and from
       # Ruby hashes, JSON strings, and CSV strings.  They're not typically used directly, but are extracted
-      # to make it easier to provide custom serialization and deserialization for +Tick+ objects not shipped
+      # to make it easier to provide custom serialization and deserialization for {Quant::Ticks::Tick} objects not shipped
       # with the library.
       # @abstract
       class Tick

data/lib/quant/ticks/spot.rb

@@ -4,7 +4,7 @@ require_relative "tick"
 
 module Quant
   module Ticks
-    # A +Spot+ is a single price point in time.  It is the most basic form of a +Tick+ and is usually used to represent
+    # A +Spot+ is a single price point in time.  It is the most basic form of a {Quant::Ticks::Tick} and is usually used to represent
     # a continuously streaming tick that just has a single price point at a given point in time.
     # @example
     #   spot = Quant::Ticks::Spot.new(price: 100.0, timestamp: Time.now)
@@ -19,9 +19,9 @@ module Quant
     class Spot < Tick
       include TimeMethods
 
-      attr_reader :interval, :series
+      attr_reader :series
       attr_reader :close_timestamp, :open_timestamp
-      attr_reader :open_price, :high_price, :low_price, :close_price
+      attr_reader :close_price
       attr_reader :base_volume, :target_volume, :trades
 
       def initialize(
@@ -30,7 +30,6 @@ module Quant
         close_price: nil,
         close_timestamp: nil,
         volume: nil,
-        interval: nil,
         base_volume: nil,
         target_volume: nil,
         trades: nil
@@ -39,8 +38,6 @@ module Quant
 
         @close_price = (close_price || price).to_f
 
-        @interval = Interval[interval]
-
         @close_timestamp = extract_time(timestamp || close_timestamp || Quant.current_time)
         @open_timestamp = @close_timestamp
 
@@ -53,6 +50,9 @@ module Quant
 
       alias timestamp close_timestamp
       alias price close_price
+      alias high_price close_price
+      alias low_price close_price
+      alias open_price close_price
       alias oc2 close_price
       alias hl2 close_price
       alias hlc3 close_price
@@ -73,7 +73,7 @@ module Quant
       end
 
       def inspect
-        "#<#{self.class.name} #{interval} ct=#{close_timestamp} c=#{close_price.to_f} v=#{volume}>"
+        "#<#{self.class.name} ct=#{close_timestamp} c=#{close_price.to_f} v=#{volume}>"
       end
     end
   end

data/lib/quant/ticks/tick.rb

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

data/lib/quant/version.rb

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

data/lib/quantitative.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quantitative
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Michael Lang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-21 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -44,25 +44,29 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/quant/asset.rb
+- lib/quant/asset_class.rb
+- lib/quant/attributes.rb
 - 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/indicators/ping.rb
+- lib/quant/indicators_proxy.rb
+- lib/quant/indicators_sources.rb
 - lib/quant/interval.rb
 - lib/quant/mixins/direction.rb
 - lib/quant/mixins/filters.rb
 - lib/quant/mixins/fisher_transform.rb
 - lib/quant/mixins/high_pass_filter.rb
 - lib/quant/mixins/hilbert_transform.rb
+- lib/quant/mixins/moving_averages.rb
 - lib/quant/mixins/stochastic.rb
 - lib/quant/mixins/super_smoother.rb
 - lib/quant/mixins/trig.rb
-- lib/quant/mixins/weighted_average.rb
 - lib/quant/refinements/array.rb
-- lib/quant/security.rb
-- lib/quant/security_class.rb
 - lib/quant/series.rb
 - lib/quant/settings.rb
 - lib/quant/settings/indicators.rb

data/lib/quant/mixins/weighted_average.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Quant
-  module Mixins
-    module WeightedAverage
-      def weighted_average(source)
-        value = source.is_a?(Symbol) ? p0.send(source) : source
-        [4.0 * value,
-         3.0 * p1.send(source),
-         2.0 * p2.send(source),
-         p3.send(source),].sum / 10.0
-      end
-
-      def extended_weighted_average(source)
-        value = source.is_a?(Symbol) ? p0.send(source) : source
-        [7.0 * value,
-         6.0 * p1.send(source),
-         5.0 * p2.send(source),
-         4.0 * p3.send(source),
-         3.0 * prev(4).send(source),
-         2.0 * prev(5).send(source),
-         prev(6).send(source),].sum / 28.0
-      end
-    end
-  end
-end

data/lib/quant/security.rb

@@ -1,80 +0,0 @@
-# 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