spacetimeid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7675891f5066fffedef7a012ff3818fa359a1d6f
+  data.tar.gz: 512877f20f6b9e5fb3059bed607364955eda7178
+SHA512:
+  metadata.gz: dca84379331ab91abaff2ed959f7c4331871d5be58a1f6076566cf8b7a892df16ed3ac6b888167f8de2f4737f47f29e04d948a50efb8c55cc7366eaf34d72321
+  data.tar.gz: 7985334f122f72f4b349dace6fe774ecd329dd3332e92d6caa3be7f58dfd9caec796901dca855224b7a08773a1d02e5ca6fab775d9542c0d3e555b9933e83e14

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,35 @@
+# SpaceTimeId
+A unique spationtemporal id implementation for use in nanocubes
+
+## General Requirements
+
+Install via rubygems
+
+```gem install spacetimeid```
+
+or add it to your Gemfile
+
+```gem 'spacetimeid'```
+
+## Example
+
+```ruby
+require 'time'
+time = Time.parse("2015-06-01T00:05:32Z")
+id = SpaceTimeId.new(time.to_i, [1.3, -3.048])
+
+id.id
+# => "1433116800_1.30_-3.05"
+
+# DEFAULTS = {
+#   xy_base_step: 0.01, # 0.01 degrees
+#   xy_expansion: 5,    # expands into a 5x5 grid recursively
+#   ts_base_step: 600,  # 10 minutes
+#   ts_expansion: [1, 3, 2, 3, 2], # each time interval expands this many times the previous one
+#   decimals: 2
+# }
+
+```
+
+### Disclaimer
+This project is written on a need to use basis for inclusion to other projects I'm working on for now, so completion is not an immediate goal.

data/lib/extract_options.rb

@@ -0,0 +1,38 @@
+if !Hash.method_defined?(:extractable_options?)
+
+  class Hash
+    # By default, only instances of Hash itself are extractable.
+    # Subclasses of Hash may implement this method and return
+    # true to declare themselves as extractable. If a Hash
+    # is extractable, Array#extract_options! pops it from
+    # the Array when it is the last element of the Array.
+    def extractable_options?
+      instance_of?(Hash)
+    end
+  end
+
+end
+
+
+if !Array.method_defined?(:extract_options!)
+
+  class Array
+    # Extracts options from a set of arguments. Removes and returns the last
+    # element in the array if it's a hash, otherwise returns a blank hash.
+    #
+    #   def options(*args)
+    #     args.extract_options!
+    #   end
+    #
+    #   options(1, 2)        # => {}
+    #   options(1, 2, a: :b) # => {:a=>:b}
+    def extract_options!
+      if last.is_a?(Hash) && last.extractable_options?
+        pop
+      else
+        {}
+      end
+    end
+  end
+
+end

data/lib/space_time_id.rb

@@ -0,0 +1,275 @@
+class SpaceTimeId
+
+  DEFAULTS = {
+    xy_base_step: 0.01, # 0.01 degrees
+    xy_expansion: 5,    # expands into a 5x5 grid recursively
+    ts_base_step: 600,  # 10 minutes
+    ts_expansion: [1, 3, 2, 3, 2], # expands 3 times each interval, then 2, then 3....
+    decimals: 2
+  }
+
+  attr_accessor :ts_sec
+  attr_accessor :x
+  attr_accessor :y
+  attr_accessor :options
+  attr_accessor :interval
+  attr_accessor :level
+
+  def initialize(*args)
+    self.options = DEFAULTS.merge(args.extract_options!)
+    self.interval = options.delete(:interval) || 0
+    self.level = options.delete(:level) || 0
+    options[:ts_expansion] = Array(options[:ts_expansion])
+    if args.length == 1 && args.first.is_a?(String)
+      initialize(*args.first.split("_").map(&:to_f), original_options)
+    elsif args.length == 1 && args.first.is_a?(Array) && args.first.length == 2
+      initialize(*(args.first), original_options)
+    elsif args.all? { |arg| arg.is_a?(Fixnum) || arg.is_a?(Float) }
+      case args.length
+      when 1
+        self.ts_sec = args.first
+        self.ts_sec = ts_id.to_i
+      when 2
+        self.x, self.y = args
+        self.x, self.y = xy_id_2d
+      when 3
+        self.ts_sec, self.x, self.y = args
+        self.x, self.y = xy_id_2d
+        self.ts_sec = ts_id.to_i
+      else
+        raise "Invalid initialize arguments! (#{args.inspect})"
+      end
+    elsif args.length == 2 &&
+        (args.first.is_a?(Fixnum) || args.first.is_a?(Float)) && args.last.is_a?(Array)
+      ts = args.first
+      x, y = args.last
+      initialize(ts, x, y, original_options)
+    else
+      raise "Invalid initialize arguments! (#{args.inspect})"
+    end
+  end
+
+  def id
+    [ts_id, xy_id_str].compact.join("_")
+  end
+
+  def to_s
+    id
+  end
+
+  def inspect
+    "<SpaceTimeId:#{id} #{original_options.inspect}>"
+  end
+
+  def to_html
+    html = "id: #{id}<br/>"
+    if ts?
+      html << "interval: #{inteval}<br/>"
+      html << "time_base_step: #{time_base_step}<br/>"
+      html << "time_expansion: #{time_expansion}<br/>"
+    end
+    if xy?
+      html << "level: #{level}<br/>"
+      html << "xy_base_step: #{xy_base_step}<br/>"
+      html << "xy_expansion: #{xy_expansion}<br/>"
+    end
+    html
+  end
+
+  def ==(other)
+    other.nil? || !other.respond_to?(:id) ? false : id == other.id
+  end
+
+  def eql?(other)
+    other.is_a?(SpaceTimeId) && self == other
+  end
+
+  def hash
+    [id, interval, level].hash
+  end
+
+  def dup(new_id = id, options = self.options)
+    SpaceTimeId.new(new_id, original_options.merge(options))
+  end
+
+  def dec
+    options[:decimals]
+  end
+
+  def original_options
+    {level: level, interval: interval}.merge(options)
+  end
+
+  # # # # # # # # # # # # T I M E # # # # # # # # # # # # # # # # # # # # # # #
+
+  def ts?
+    !ts_sec.nil?
+  end
+
+  def ts
+    Time.at(ts_sec) if ts_sec
+  end
+
+  def ts_ms
+    ts_sec * 1000 if ts_sec
+  end
+
+  def ts_id
+    digitize(ts_sec, ts_step).to_i if ts_sec
+  end
+
+  def ts_step
+    @ts_step ||= ts_step_aux(interval)
+  end
+
+  def ts_step_aux(interval)
+    ts_base_step * ts_expansion
+  end
+
+  def ts_base_step
+    options[:ts_base_step]
+  end
+
+  def ts_expansion
+    ts_expansion_aux
+    options[:ts_expansion][0..interval].reduce(:*)
+  end
+
+  def ts_expansion_aux
+    if interval >= options[:ts_expansion].length
+      padd = [options[:ts_expansion].last] * (options[:ts_expansion].length - interval + 1)
+      options[:ts_expansion] += padd
+    end
+  end
+
+  # # # # # # # # # # # # # T I M E   R E L A T I O N S # # # # # # # # # # # #
+
+  def next_ts(i = 1)
+    @_next_ts ||= {}
+    @_next_ts[i] ||= digitize(ts_id + ts_step * i + ts_step / 2.0, ts_step) if ts?
+  end
+
+  def ts_neighbors
+    @ts_neighbors ||= begin
+      prevt = dup(next_ts(-1))
+      nextt = dup(next_ts)
+      @ts_neighbors = [prevt, nextt]
+    end if ts?
+  end
+
+  def ts_parent
+    dup(id, interval: interval + 1) if ts?
+  end
+
+  # # # # # # # # # # # # S P A C E # # # # # # # # # # # # # # # # # # # # # #
+
+  def xy?
+    !xy.empty?
+  end
+
+  def xy
+    [x, y].compact
+  end
+
+  def xy_id_2d
+    xy.map { |c| digitize(c, xy_step).round(dec) } if xy?
+  end
+
+  def xy_id_str
+    xy.map { |c| digitize_str(c, xy_step, dec) } .join("_") if xy?
+  end
+
+  def xy_id_2d_center
+    xy_id_2d.map { |c| (c + (xy_step / 2.0)).round(dec * 2) } if xy?
+  end
+
+  def xy_id_str_center
+    xy_id_2d_center.map { |c| digitize_str(c, (xy_step / 2.0), dec * 2) } .join("_") if xy?
+  end
+
+  def xy_step
+    (xy_expansion ** level) * xy_base_step
+  end
+
+  def xy_base_step
+    options[:xy_base_step]
+  end
+
+  def xy_expansion
+    options[:xy_expansion]
+  end
+
+  # # # # # # # # # # # # S P A C E   R E L A T I O N S # # # # # # # # # # # #
+
+  def next_x(i = 1)
+    @_next_x ||= {}
+    @_next_x[i] ||= digitize(x + xy_step * i + xy_step / 2.0, xy_step) if xy?
+  end
+
+  def next_y(i = 1)
+    @_next_y ||= {}
+    @_next_y[i] ||= digitize(y + xy_step * i + xy_step / 2.0, xy_step) if xy?
+  end
+
+  def xy_neighbors
+    @xy_neighbors ||= begin
+      topLeft      = dup([next_x(-1), next_y(1) ])
+      top          = dup([x         , next_y(1) ])
+      topRight     = dup([next_x(1) , next_y(1) ])
+      right        = dup([next_x(1) , y         ])
+      bottomRight  = dup([next_x(1) , next_y(-1)])
+      bottom       = dup([x         , next_y(-1)])
+      bottomLeft   = dup([next_x(-1), next_y(-1)])
+      left         = dup([next_x(-1), y         ])
+      @xy_neighbors = [topLeft, top, topRight, right, bottomRight, bottom, bottomLeft, left]
+    end if xy?
+  end
+
+  def xy_parent
+    dup(id, level: level + 1) if xy?
+  end
+
+  def xy_children
+    raise "No children for level zero!" if level == 0
+    @xy_children ||= begin
+      bottom_left = dup(id, level: level - 1)
+      @xy_children = []
+      (0...xy_expansion).each do |h|
+        (0...xy_expansion).each do |v|
+          @xy_children << bottom_left.dup([bottom_left.next_x(h), bottom_left.next_y(v)])
+        end
+      end
+      @xy_children
+    end if xy?
+  end
+
+  def xy_descendants
+    xy_children + (level == 1 ? [] : xy_children.map(&:xy_descendants).flatten) if xy?
+  end
+
+  def xy_siblings
+    xy_parent.xy_children if xy?
+  end
+
+  def xy_four_corners
+    [xy, [next_x, y], [next_x, next_y], [x, next_y], xy] if xy?
+  end
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+  private
+
+  def digitize n, step
+    # JS method to avoid floating point rounding errors: 85.000000000000001
+    # Math.floor((c + @baseStep / 1000) / @baseStep) / (1 / @baseStep)
+    step = step.to_f
+    ((n + step / 1000) / step).floor / (1 / step)
+  end
+
+  def digitize_str n, step, dec = 2
+    n = digitize n, step
+    "%.#{dec}f" % n
+  end
+
+end

data/lib/spacetimeid.rb

@@ -0,0 +1,2 @@
+require 'extract_options'
+autoload :SpaceTimeId, 'space_time_id'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: spacetimeid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- George Lamprianidis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unified space and time id with hierarchy in both dimensions!
+email: giorgos.lamprianidis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/extract_options.rb
+- lib/space_time_id.rb
+- lib/spacetimeid.rb
+homepage: https://github.com/glampr/spacetimeid
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Unified space and time id with hierarchy in both dimensions!
+test_files: []