pacer-scale 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ae24a6f4ae17b93d6b101672bd2d239a66fdef1
+  data.tar.gz: 57532b97c2689e75cf43079db59b96f6498d5038
+SHA512:
+  metadata.gz: 48af340eab76ba9c58e157b4fd09e0729f50655f2c5bb93b76011e57645cb15247f482d87c3e32b85cc28c55bea8caacaa1bf2ba3de94a274dc0f254a8213d28
+  data.tar.gz: 29fa6867b7615aacaea03faf9ee5aac3e069042ac9e730e498c345b63ccb2f35d639bf10e6c54f65e23114e8f46561502040fb1b31025b8a4a5fdb89629c5bf9

data/Jarfile

@@ -0,0 +1,6 @@
+repository "https://repo1.maven.org/maven2/"
+repository "https://clojars.org/repo/"
+jar "org.clojure:clojure:1.7.0-alpha6"
+jar "com.tinkerpop.blueprints:blueprints-core:2.6.0"
+jar "com.tinkerpop:pipes:2.6.0"
+jar "com.tinkerpop.gremlin:gremlin-java:2.6.0"

data/spec/pacer-scale_spec.rb

@@ -0,0 +1,23 @@
+$: << 'src/ruby'
+require 'spec_helper'
+
+describe 'simple rating scale' do
+  before do
+    @g = Pacer.tg
+    @root = @g.create_vertex(PacerScale::Root)
+    @root.generate_scale 'ranking', 1, 10, 1
+  end
+
+  it 'should find each valid ranking' do
+    v = @root.find 'ranking', 1
+    v.should_not be_nil
+  end
+
+  it 'should find each valid ranking' do
+    (1..10).each do |n|
+      v = @root.find 'ranking', n
+      v.should_not be_nil
+      v.value.should == n
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,76 @@
+require 'pacer-scale'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :should
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  #Kernel.srand config.seed
+end

data/src/ruby/pacer-scale.rb

@@ -0,0 +1,159 @@
+require 'pacer-scale/version'
+require 'pacer'
+require 'lock_jar'
+LockJar.lock File.join(File.dirname(__FILE__), '../../Jarfile'), lockfile: 'Jarfile.pacer-mcfly.lock'
+LockJar.load 'Jarfile.pacer-mcfly.lock'
+require 'xn_graph_scale.jar'
+
+module PacerScale
+  import java.math.BigDecimal
+  import Java::clojure.java.api.Clojure
+  import Java::xn.graph.scale.ScaleRangePipe
+
+  class << self
+    def generate_scale(graph, min, max, step)
+      Clojure.var('clojure.core', 'require').invoke(['xn.graph.scale.core'])
+      gs = Clojure.var('xn.graph.scale.core', 'generate-scale')
+      v = gs.invoke(graph.blueprints_graph, min.to_i, max.to_i, BigDecimal.new(step.to_s))
+      graph.vertex(v.getId, Value) if v
+    end
+  end
+
+  module Root
+    module Vertex
+      def generate_scale(label, min, max, step)
+        v = PacerScale.generate_scale(graph, min, max, step)
+        add_edges_to(label, v)
+        v[:root_edge] = label
+        self
+      end
+
+      def find(label, val)
+        out(label, Value).first.find val
+      end
+
+      def find_range(label, val, tolerance)
+        out(label, Value).first.find_range val, tolerance
+      end
+    end
+  end
+
+  module Value
+    module Vertex
+      def value
+        v = self[:scale_value]
+        v.to_f if v
+      end
+
+      def min
+        v = self[:scale_min]
+        v.to_f if v
+      end
+
+      def max
+        v = self[:scale_max]
+        v.to_f if v
+      end
+
+      def step
+        v = self[:scale_step]
+        v.to_f if v
+      end
+
+      def root
+        v = find(min)
+        v.in(v[:root_edge], Root) if v
+      end
+
+      def next
+        out(:next_1, Value)
+      end
+
+      def prev
+        self.in(:next_1, Value)
+      end
+
+      def find(val)
+        # calculate offset from current position...
+        offset(val - value, 0).first
+      end
+
+      def offset(offset_by, tolerance)
+        _as_scale.offset(offset_by, tolerance)
+      end
+
+      def below(offset_by = 0)
+        _as_scale.below_traversal(offset_by)
+      end
+
+      def above(offset_by = 0)
+        _as_scale.above_traversal(offset_by)
+      end
+
+      def find_range(val, tolerance)
+        # calculate offset_by from current position...
+        offset(val - value, tolerance)
+      end
+
+      protected
+
+      def _as_scale
+        chain_route(filter: PacerScale::RangeTraversal,
+                    min: min, max: max, step: step)
+      end
+    end
+
+    module Route
+      def as_scale(min, max, step)
+        chain_route(filter: PacerScale::RangeTraversal,
+                    min: min, max: max, step: step)
+      end
+    end
+  end
+
+  module RangeTraversal
+    attr_accessor :min, :max, :step, :offset_by, :above_tolerance, :below_tolerance
+
+    def offset(offset_by, t_below, t_above = nil)
+      t_above ||= t_below
+      @offset_by = offset_by
+      @below_tolerance = t_below
+      @above_tolerance = t_above
+      v(extensions)
+    end
+
+    def above(offset_by = 0)
+      @offset_by = offset_by
+      @below_tolerance = 0
+      @above_tolerance = nil
+      v(extensions)
+    end
+
+    def below(offset_by = 0)
+      @offset_by = offset_by
+      @below_tolerance = nil
+      @above_tolerance = 0
+      v(extensions)
+    end
+
+    protected
+
+    def bigdec(n)
+      BigDecimal.new(n.to_s) if n
+    end
+
+    def inspect_string
+      if above_tolerance == below_tolerance
+        "offset(#{ offset_by }, #{above_tolerance})"
+      else
+        "offset(#{ offset_by }, #{below_tolerance.inspect}, #{above_tolerance.inspect})"
+      end
+    end
+
+    def attach_pipe(end_pipe)
+      pipe = ScaleRangePipe.new(min, max, bigdec(step), bigdec(offset_by || 0), bigdec(below_tolerance), bigdec(above_tolerance))
+      pipe.set_starts end_pipe if end_pipe
+      pipe
+    end
+  end
+end

data/src/ruby/pacer-scale/version.rb

@@ -0,0 +1,3 @@
+module PacerScale
+  VERSION = "0.1.0"
+end

data/test/xn/graph/scale/core_test.clj

@@ -0,0 +1,194 @@
+(ns xn.graph.scale.core-test
+  (:use xn.graph.scale.core
+        criterium.core)
+  (import java.math.BigDecimal
+          (com.tinkerpop.blueprints Graph Direction Edge Element Vertex)
+          com.tinkerpop.blueprints.impls.tg.TinkerGraph
+          xn.graph.scale.ScaleRangePipe)
+  (:require [clojure.test :refer [deftest is]]
+            [clojure.test.check.clojure-test :refer [defspec]]
+            [clojure.test.check :as tc]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]))
+
+(defspec
+  steps-add-up-to-traversal-distance
+  100 ;; the number of iterations for test.check to test
+  (prop/for-all [from gen/pos-int
+                 to gen/pos-int]
+                (= (- to from)
+                   (apply + (traversal-steps from to)))))
+
+(defn big-traversal [from to multiplier]
+  (let [from (* from (inc multiplier) (inc multiplier))
+        to   (* to   (inc multiplier) (inc multiplier))
+        steps (traversal-steps from to)]
+    (= (- to from)
+       (apply + steps))))
+
+(defspec
+  bigger-steps-add-up-to-traversal-distance
+  100
+  (prop/for-all [from gen/pos-int
+                 to gen/pos-int
+                 multiplier gen/pos-int]
+                (big-traversal from to multiplier)))
+
+(def gen-decimal
+  (->> gen/ratio
+       (gen/fmap #(try
+                    (BigDecimal. (str (float (if (neg? %) (* -1 %) %))))
+                    (catch ArithmeticException e nil)))
+       (gen/such-that some?)))
+
+(defn gen-nonzero [gen]
+  (gen/such-that #(not (zero? %)) gen))
+
+(defn predicted-edges [max-idx]
+  (reduce
+    (fn [m d]
+      (if-let [data (->> (range 0 max-idx)
+                         (filter #(= 0 (mod % d)))
+                         (partition 2 1)
+                         seq)]
+        (assoc m d data)
+        m))
+    {}
+    distances))
+
+(defspec
+  generate-various-scales
+  100
+  (prop/for-all
+    [[from to step]
+     (->> (gen/tuple gen/int gen/int (gen-nonzero gen-decimal) gen/int)
+          (gen/fmap (fn [[from to step mult]]
+                      [(* from mult) (* to mult) step]))
+          (gen/such-that (fn [[from to]] (not= from to)))
+          (gen/fmap
+            (fn [[from to step]]
+              (if (< from to)
+                [from to step]
+                [to from step])))
+          (gen/fmap
+            (fn [[from to step]]
+              (loop [from from to to step step]
+                (if (<= (- to from) step)
+                  (recur from to (/ step 2))
+                  [from to step])))))]
+    (let [vertices (atom (transient []))
+          edges (atom (transient {}))]
+      (with-redefs [scale-vertex
+                    (fn [g scale i]
+                      (swap! vertices conj! i)
+                      i)
+                    scale-edge
+                    (fn [g from to dist]
+                      (swap! edges assoc! dist (conj (@edges dist []) [from to])))]
+        (generate-scale nil from to step)
+        (let [max-idx (inc (long (Math/round (/ (double (- to from)) (double step)))))]
+          ;(prn [from to step] max-idx)
+          (is (= (range 0 max-idx)
+                 (persistent! @vertices)))
+          (is (= (predicted-edges max-idx)
+                 (persistent! @edges))))))))
+
+
+
+(let [g (TinkerGraph.)
+      v0 (generate-scale g -500 500 0.1M)
+      label (into-array String ["next_1"])
+      actual (loop [actual {} v v0]
+               (if v
+                 (recur (assoc actual (value v) v)
+                        (first (.getVertices ^Vertex v Direction/OUT label)))
+                 actual))]
+  (defspec
+    navagate-a-real-scale
+    1000
+    (prop/for-all
+      [[start offset tolerance] (->> (gen/tuple gen/int gen/int gen/ratio)
+                                     (gen/fmap
+                                       (fn [[s o t]]
+                                         (if (neg? t) [s o (- t)] [s o t])))
+                                     (gen/such-that
+                                       (fn [[s o t]]
+                                         (and (<= -500 s 500)
+                                              (<= -500 (+ s o (- t)) (+ s o t) 500)))))]
+      (let [start (BigDecimal. (str start))
+            s (actual start)
+            expected (actual (+ start offset))
+            tolerance (BigDecimal. (str (double tolerance)))
+            f (scale-range -500 500 0.1M (BigDecimal. (str offset)) tolerance tolerance)
+            r (f s)]
+        (is (some #{expected} r)))))
+
+  (deftest test-range-end
+    (let [f (scale-range -500 500 0.1M 1000M 0M 0M)]
+      (is (not (empty? (f v0))))
+      (is (= [500M] (map value (f v0))))))
+
+  (deftest test-range-pipe
+    (let [pipe (ScaleRangePipe. -500 500 0.1M 550M 1M 5M)
+          a (java.util.ArrayList.)]
+      (.add a v0)
+      (.setStarts pipe a)
+      (is (= (into [] (map actual) (range 49M 55.01M 0.1M))
+             (into [] (seq pipe)))))))
+
+
+(defspec
+  no-falling-off-the-head
+  1000
+  (prop/for-all
+    [[low high] (->> (gen/tuple gen/pos-int gen/pos-int)
+                     (gen/such-that (fn [[l h]] (not= l h)))
+                     (gen/fmap (fn [[l h]] (if (< l h) [l h] [h l]))))]
+    (let [g (TinkerGraph.)
+          v0 (generate-scale g low high 1M)
+          label (into-array String ["next_1"])
+          ^Vertex vn (loop [vn v0 ^Vertex v v0]
+                       (if v
+                         (recur v
+                                (first (.getVertices v Direction/OUT label)))
+                         vn))]
+      (every? (fn [n]
+                (let [f (scale-range low high 1M (- n) 0M 0M)
+                      data (doall (f vn))
+                      expected (- high n)]
+                  (is (= [expected] (map value data)))))
+              (range 0M (BigDecimal. (str (- high low))))))))
+
+
+(defspec
+  no-falling-off-the-end
+  100
+  (prop/for-all
+    [[low high] (->> (gen/tuple gen/int gen/int)
+                     (gen/such-that (fn [[l h]] (not= l h)))
+                     (gen/fmap (fn [[l h]] (if (< l h) [l h] [h l]))))]
+    (let [g (TinkerGraph.)
+          v0 (generate-scale g low high 1M)]
+      (every? (fn [n]
+                (let [f (scale-range low high 1M n 0M 0M)]
+                  (is (= [(+ low n)] (map value (f v0))))))
+              (range 0M (BigDecimal. (str (- high low))))))))
+
+
+
+
+(deftest inline-tests
+  (test #'tests))
+
+(comment
+  (drop 9900 (gen/sample
+    (gen/fmap (fn [[a b c]] [(* a c) (* b c)])
+              (gen/tuple gen/pos-int gen/pos-int gen/pos-int))
+    10000))
+
+  (gen/sample (gen/such-that #(not (zero? %)) gen-decimal) 100)
+  (gen/sample (gen/such-that #(apply not= %) (gen/tuple gen/int gen/int)) 1000)
+
+  (quick-bench (remove-oversized-steps {:min 0 :max 100 :step 1M} 0 [100 -1 -1 -1]))
+  (bench (remove-oversized-steps {:min 0 :max 99 :step 1M} 0 [100 -1 -1 -1]))
+  (quick-bench (traversal-steps 3608 943)))

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: pacer-scale
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: java
+authors:
+- Darrick Wiebe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lock_jar
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: pacer
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: builder
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: xn_gem_release_tasks
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.21
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.21
+  prerelease: false
+  type: :development
+description: Generate and produce ranges in scale data structures in the graph
+email:
+- dw@xnlogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Jarfile
+- spec/pacer-scale_spec.rb
+- spec/spec_helper.rb
+- src/ruby/pacer-scale.rb
+- src/ruby/pacer-scale/version.rb
+- src/ruby/xn_graph_scale.jar
+- test/xn/graph/scale/core_test.clj
+homepage: http://xnlogic.com
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- src/ruby
+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: pacer-scale
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Scale plugin for Pacer
+test_files:
+- spec/pacer-scale_spec.rb
+- spec/spec_helper.rb
+- test/xn/graph/scale/core_test.clj