hyper-d3 1.0.0.lap23

data/spec/quadtree_spec.rb

@@ -0,0 +1,128 @@
+describe "d3 - quadtree" do
+  let(:a) { [1,2,"a"] }
+  let(:a2) { [1,2,"a"] }
+  let(:b) { [3,4,"b"] }
+  let(:c) { [5,6,"c"] }
+  let(:d) { [7,8,"c"] }
+  let(:e) { [3,4,"e"] }
+
+  it "d3.quadtree" do
+    expect(D3.quadtree).to be_instance_of(D3::QuadTree)
+  end
+
+  it "quadtree.size" do
+    q = D3.quadtree
+    expect(q.size).to eq(0)
+    expect(q.add(a).size).to eq(1)
+    expect(q.add(b).size).to eq(2)
+  end
+
+  it "quadtree.remove" do
+    q = D3.quadtree
+    expect(q.size).to eq(0)
+    expect(q.add(a).add(b).size).to eq(2)
+    expect(q.remove(a2).size).to eq(2)
+    expect(q.remove(a).size).to eq(1)
+    expect(q.remove(c).size).to eq(1)
+  end
+
+  it "quadtree.remove_all" do
+    q = D3.quadtree([a,b,c])
+    expect(q.remove_all([b,d]).data).to eq([a,c])
+  end
+
+  it "quadtree.data" do
+    q = D3.quadtree
+    expect(q.data).to eq([])
+    expect(q.add(a).data).to eq([a])
+    expect(q.add_all([b,c]).data).to eq([a,b,c])
+  end
+
+  it "quadtree.find" do
+    q = D3.quadtree
+    expect(q.find(1,1)).to eq(nil)
+    q.add([1,2,"foo"])
+    expect(q.find(3,3)).to eq([1,2,"foo"])
+    expect(q.find(3,3,1)).to eq(nil)
+  end
+
+  it "quadtree.copy" do
+    q1 = D3.quadtree.add(a)
+    q2 = q1.copy.add(b)
+    q1.add(c)
+    expect(q1.data).to eq([a,c])
+    expect(q2.data).to eq([a,b])
+  end
+
+  it "quadtree.visit" do
+    q = D3.quadtree([a,b,c,e])
+    called = []
+    q.visit do |node, x0, y0, x1, y1|
+      called << [x0, y0, x1, y1, node.internal?, node.leaf?, node.data, !!node.next, node.children && node.children.map{|x| !!x}]
+      false
+    end
+    expect(called).to eq([
+      [1, 2, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [1, 2, 3, 4, false, true, [1, 2, "a"], false, nil],
+      [3, 4, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [3, 4, 4, 5, false, true, [3, 4, "e"], true, nil],
+      [4, 5, 5, 6, false, true, [5, 6, "c"], false, nil],
+    ])
+  end
+
+  it "quadtree.visit_after" do
+    q = D3.quadtree([a,b,c,e])
+    called = []
+    q.visit_after do |node, x0, y0, x1, y1|
+      called << [x0, y0, x1, y1, node.internal?, node.leaf?, node.data, !!node.next, node.children && node.children.map{|x| !!x}]
+      false
+    end
+    expect(called).to eq([
+      [1, 2, 3, 4, false, true, [1, 2, "a"], false, nil],
+      [3, 4, 4, 5, false, true, [3, 4, "e"], true, nil],
+      [4, 5, 5, 6, false, true, [5, 6, "c"], false, nil],
+      [3, 4, 5, 6, true, false, nil, false, [true, false, false, true]],
+      [1, 2, 5, 6, true, false, nil, false, [true, false, false, true]],
+    ])
+  end
+
+  it "quadtree.root" do
+    q = D3.quadtree([a,b,c])
+    root = q.root
+    expect(root).to be_instance_of(D3::Quad)
+    expect(root).to be_internal
+  end
+
+  it "quadtree.extent" do
+    q = D3.quadtree([a,b,c])
+    expect(q.extent).to eq([[1, 2], [5, 6]])
+    expect(q.extent([[0,0],[10,1]]).extent([[-1,-1],[1,1]]).extent).to eq([[-3, -10], [13, 6]])
+  end
+
+  it "quadtree.cover" do
+    q = D3.quadtree([a,b,c])
+    expect(q.extent).to eq([[1, 2], [5, 6]])
+    expect(q.cover(0,0).cover(-2,10).extent).to eq([[-11, -2], [5, 14]])
+  end
+
+  it "quadtree.x/y defaults" do
+    q = D3.quadtree([a,b,c])
+    expect(q.x.(c)).to eq(5)
+    expect(q.y.(c)).to eq(6)
+  end
+
+  it "quadtree.x/y constructor" do
+    q = D3.quadtree([a,b,c], proc{|(x,y,n)| x*10}, proc{|(x,y,n)| y*10})
+    expect(q.x.(c)).to eq(50)
+    expect(q.y.(c)).to eq(60)
+    expect(q.extent).to eq([[10, 20], [74, 84]])
+  end
+
+  it "quadtree.x/y" do
+    q = D3.quadtree
+    q.x{|(x,y,n)| y*100}.y{|(x,y,n)| x*100}.add_all([a,b,c])
+    expect(q.x.(c)).to eq(600)
+    expect(q.y.(c)).to eq(500)
+    expect(q.extent).to eq([[200, 100], [712, 612]])
+  end
+end

data/spec/quantile_scale_spec.rb

@@ -0,0 +1,24 @@
+describe "d3 - quantile scale" do
+  it "d3.scale_quantile" do
+    expect(D3.scale_quantile).to be_instance_of(D3::QuantileScale)
+  end
+
+  it "basics" do
+    q = D3.scale_quantile.domain([0,10]).range(("a".."f").to_a)
+    expect(q.(4)).to eq("c")
+
+    expect(q.domain).to eq([0,10])
+    expect(q.range).to eq(("a".."f").to_a)
+    expect(q.quantiles).to eq([1.6666666666666665, 3.333333333333333, 5, 6.666666666666666, 8.333333333333334])
+    expect(q.invert_extent("e")).to eq([6.666666666666666, 8.333333333333334])
+  end
+
+  it "copy" do
+    q = D3.scale_quantile.domain([1,5]).range(["x", "y"])
+    qc = q.copy.domain([0,20])
+    expect(qc.domain).to eq([0,20])
+    expect(qc.range).to eq(["x", "y"])
+    expect(q.domain).to eq([1,5])
+    expect(q.range).to eq(["x", "y"])
+  end
+end

data/spec/quantize_scale_spec.rb

@@ -0,0 +1,40 @@
+describe "d3 - quantize scale" do
+  let(:color) { D3.scale_quantize.domain([0, 1]).range(["brown", "steelblue"]) }
+  let(:width) { D3.scale_quantize.domain([10, 100]).range([1, 2, 4]) }
+
+  it "d3.quantize_scale" do
+    expect(D3.scale_quantize).to be_instance_of(D3::QuantizeScale)
+  end
+
+  it "basics - color" do
+    expect(color.(0.49)).to eq("brown")
+    expect(color.(0.51)).to eq("steelblue")
+    expect(color.domain).to eq([0,1])
+    expect(color.range).to eq(["brown", "steelblue"])
+  end
+
+  it "basics - width" do
+    expect(width.(20)).to eq(1)
+    expect(width.(50)).to eq(2)
+    expect(width.(80)).to eq(4)
+    expect(width.invert_extent(2)).to eq([40, 70])
+  end
+
+  it ".nice / .copy" do
+    s = D3.scale_quantize.domain([7, 109]).range([1, 2, 4])
+    sc = s.copy
+    expect(s.nice().domain).to eq([0, 110])
+    expect(sc.domain).to eq([7, 109])
+  end
+
+  it ".ticks" do
+    expect(width.ticks).to eq([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
+    expect(width.ticks(5)).to eq([20, 40, 60, 80, 100])
+  end
+
+  it ".tick_format" do
+    expect(width.tick_format.(30)).to eq("30")
+    expect(width.tick_format(5).(30)).to eq("30")
+    expect(width.tick_format(5, "+%").(30)).to eq("+3000%")
+  end
+end

data/spec/radial_area_spec.rb

@@ -0,0 +1,123 @@
+describe "d3 - radial area" do
+  it "d3.radial_area" do
+    expect(D3.radial_area).to be_instance_of(D3::RadialAreaGenerator)
+  end
+
+  let(:simple_data) {[
+    {year: 2007, value: 93.24},
+    {year: 2008, value: 95.35},
+    {year: 2009, value: 98.84},
+    {year: 2010, value: 99.92},
+    {year: 2011, value: 99.80},
+    {year: 2014, value: 99.47},
+  ]}
+
+  describe "basics" do
+    let(:radial_area) {
+      D3.radial_area
+          .angle{|d| (d[:year]-2000)/10 }
+          .outer_radius{|d| d[:value] }
+          .inner_radius(50)
+    }
+    it "basics" do
+      expect(radial_area.(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31
+        L68.4,-66.43
+        L77.42,-61.44
+        L84.08,-53.99
+        L88.94,-45.27
+        L98.02,-16.91
+        L49.27,-8.5
+        L44.56,-22.68
+        L42.07,-27.02
+        L39.17,-31.08
+        L35.87,-34.84
+        L32.21,-38.24
+        Z
+      ].join)
+    end
+
+    it "curve" do
+      expect(radial_area.curve).to be_instance_of(D3::Curve)
+      expect(radial_area.curve(D3.curve_natural).(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31C62.74,-69.61,65.42,-67.91,68.4,-66.43
+        C71.38,-64.95,74.66,-63.68,77.42,-61.44
+        C80.19,-59.2,82.45,-55.98,84.08,-53.99
+        C85.71,-52,86.72,-51.24,88.94,-45.27
+        C91.16,-39.29,94.59,-28.1,98.02,-16.91
+        L49.27,-8.5
+        C47.49,-14.1,45.72,-19.7,44.56,-22.68
+        C43.4,-25.66,42.87,-26.01,42.07,-27.02
+        C41.28,-28.02,40.23,-29.66,39.17,-31.08
+        C38.1,-32.5,37.03,-33.68,35.87,-34.84
+        C34.71,-35.99,33.46,-37.12,32.21,-38.24
+        Z
+      ].join)
+    end
+
+
+    it ".defined" do
+      expect(radial_area.defined{|d| d[:year] != 2010}.(simple_data).gsub(/\d+\.\d+/){$&.to_f.round(2)}).to eq(%W[
+        M60.07,-71.31
+        L68.4,-66.43
+        L77.42,-61.44
+        L39.17,-31.08
+        L35.87,-34.84
+        L32.21,-38.24
+        Z
+        M88.94,-45.27
+        L98.02,-16.91
+        L49.27,-8.5
+        L44.56,-22.68
+        Z
+      ].join)
+    end
+  end
+
+  describe "line generators" do
+    let(:radial_area) {
+      D3.radial_area
+        .start_angle{|d| (d[:year]-2000)/20 }
+        .end_angle{|d| (d[:year]-2000)/10 }
+        .outer_radius{|d| d[:value] }
+        .inner_radius(50)
+    }
+    let(:point) { {year: 2042, value: 117 } }
+
+    it ".angle/.start_angle/.end_angle" do
+      expect(radial_area.start_angle.(point)).to eq(2.1)
+      expect(radial_area.end_angle.(point)).to eq(4.2)
+      expect(radial_area.angle.(point)).to eq(2.1)
+    end
+
+    it ".radius/.inner_radius/.outer_radius" do
+      expect(radial_area.inner_radius.(point)).to eq(50)
+      expect(radial_area.outer_radius.(point)).to eq(117)
+      expect(radial_area.radius.(point)).to eq(50)
+    end
+
+    it ".line_start_angle" do # start_angle inner_radius
+      expect(radial_area.line_start_angle).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_start_angle.angle.(point)).to eq(2.1)
+      expect(radial_area.line_start_angle.radius.(point)).to eq(50)
+    end
+
+    it ".line_end_angle" do # end_angle inner_radius
+      expect(radial_area.line_end_angle).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_end_angle.angle.(point)).to eq(4.2)
+      expect(radial_area.line_end_angle.radius.(point)).to eq(50)
+    end
+
+    it ".line_inner_radius" do # start_angle inner_radius
+      expect(radial_area.line_inner_radius).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_inner_radius.angle.(point)).to eq(2.1)
+      expect(radial_area.line_inner_radius.radius.(point)).to eq(50)
+    end
+
+    it ".line_outer_radius" do # start_angle outer_radius
+      expect(radial_area.line_outer_radius).to be_instance_of(D3::RadialLineGenerator)
+      expect(radial_area.line_outer_radius.angle.(point)).to eq(2.1)
+      expect(radial_area.line_outer_radius.radius.(point)).to eq(117)
+    end
+  end
+end

data/spec/radial_line_spec.rb

@@ -0,0 +1,50 @@
+describe "d3 - radial line" do
+  it "d3.radial_line" do
+    expect(D3.radial_line).to be_instance_of(D3::RadialLineGenerator)
+  end
+
+  let(:simple_data) { [[0,2],[Math::PI*0.10,5],[Math::PI*0.20,3]] }
+
+  it "basics" do
+    expect(D3.radial_line.(simple_data)).to eq("M0,-2L1.545084971874737,-4.755282581475767L1.7633557568774194,-2.4270509831248424")
+  end
+
+  it "curve" do
+    expect(D3.radial_line.curve).to be_instance_of(D3::Curve)
+    expect(D3.radial_line.curve(D3.curve_natural).(simple_data)).to eq(%W[
+      M0,-2
+      C0.6255961728642502,-3.3420537088108135,1.2511923457285004,-4.684107417621627,1.545084971874737,-4.755282581475767
+      C1.8389775980209737,-4.826457745329908,1.8011666774491966,-3.626754364227375,1.7633557568774194,-2.4270509831248424
+    ].join)
+  end
+
+  it "angle/radius accessors" do
+    radial_line = D3.radial_line
+    radial_line.angle{|(a,r)| a*2}.radius{|(a,r)| r*100}
+    expect(radial_line.angle.([2,42])).to eq(4)
+    expect(radial_line.radius.([2,42])).to eq(4200)
+    expect(radial_line.(simple_data)).to eq("M0,-200L293.8926261462366,-404.5084971874737L285.31695488854604,-92.70509831248424")
+  end
+
+  it ".angle constant" do
+    radial_line = D3.radial_line.angle(Math::PI)
+    expect(radial_line.(simple_data)).to eq("M2.4492935982947064e-16,2L6.123233995736766e-16,5L3.6739403974420594e-16,3")
+    expect(radial_line.angle.(42)).to eq(Math::PI)
+    radial_line.angle = 20
+    expect(radial_line.angle.(42)).to eq(20)
+  end
+
+  it ".radius constant" do
+    radial_line = D3.radial_line.radius(10)
+    expect(radial_line.(simple_data)).to eq("M0,-10L3.090169943749474,-9.510565162951535L5.877852522924732,-8.090169943749475")
+    expect(radial_line.radius.(42)).to eq(10)
+    radial_line.radius = 20
+    expect(radial_line.radius.(42)).to eq(20)
+  end
+
+  it ".defined" do
+    radial_line = D3.radial_line.defined{|(a,r)| r.even?}
+    data = [[0,6], [0,10], [0,11], [0,14], [0,16], [0,19]]
+    expect(radial_line.(data)).to eq("M0,-6L0,-10M0,-14L0,-16")
+  end
+end

data/spec/random_spec.rb

@@ -0,0 +1,34 @@
+describe "d3-random" do
+  # Not really testing anything more meaningful,
+  # just that they return some numbers
+  # http://xkcd.com/221/
+  it "d3.random_uniform" do
+    expect(D3.random_uniform.call).to be_a(Numeric)
+    expect(D3.random_uniform(10).call).to be_a(Numeric)
+    expect(D3.random_uniform(10,20).call).to be_a(Numeric)
+  end
+
+  it "d3.random_normal" do
+    expect(D3.random_normal.call).to be_a(Numeric)
+    expect(D3.random_normal(10).call).to be_a(Numeric)
+    expect(D3.random_normal(10, 2).call).to be_a(Numeric)
+  end
+
+  it "d3.random_log_normal" do
+    expect(D3.random_log_normal.call).to be_a(Numeric)
+    expect(D3.random_log_normal(10).call).to be_a(Numeric)
+    expect(D3.random_log_normal(10, 2).call).to be_a(Numeric)
+  end
+
+  it "d3.random_bates" do
+    expect(D3.random_bates(5).call).to be_a(Numeric)
+  end
+
+  it "d3.random_irwin_hall" do
+    expect(D3.random_irwin_hall(5).call).to be_a(Numeric)
+  end
+
+  it "d3.random_exponential" do
+    expect(D3.random_exponential(3).call).to be_a(Numeric)
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,69 @@
+describe "d3-array - search" do
+  it "d3.ascending" do
+    expect(D3.ascending(2,1)).to eq(1)
+    expect(D3.ascending(1,1)).to eq(0)
+    expect(D3.ascending(1,2)).to eq(-1)
+  end
+
+  it "d3.descending" do
+    expect(D3.descending(2,1)).to eq(-1)
+    expect(D3.descending(1,1)).to eq(0)
+    expect(D3.descending(1,2)).to eq(1)
+  end
+
+  it "d3.scan" do
+    array = [13,5,11,26,32]
+    expect(D3.scan(array)).to eq(1)
+    expect(D3.scan(array){|a,b| (a%10) - (b%10)}).to eq(2)
+    expect(D3.scan(array){|a,b| (b%10) - (a%10)}).to eq(3)
+  end
+
+  it "d3.bisect_left" do
+    array = (100..200).to_a
+    expect(D3.bisect_left(array, 117)).to eq(17)
+    expect(D3.bisect_left(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisect_right" do
+    array = (100..200).to_a
+    expect(D3.bisect_right(array, 117)).to eq(18)
+    expect(D3.bisect_right(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisect" do
+    array = (100..200).to_a
+    expect(D3.bisect(array, 117)).to eq(18)
+    expect(D3.bisect(array, 130.5)).to eq(31)
+  end
+
+  it "d3.bisector" do
+    expect(D3.bisector{|x| x.abs}).to be_instance_of(D3::Bisector)
+    expect(D3.bisector{|x,y| x.abs - y.abs}).to be_instance_of(D3::Bisector)
+  end
+
+  describe "D3::Bisector" do
+    let(:array) { (100..200).map{|i| i * (-1)**i} }
+    let(:a) { D3.bisector{|x| x.abs} }
+    let(:c) { D3.bisector{|x,y| x.abs - y.abs} }
+
+    it "A.left" do
+      expect(a.left(array, 117)).to eq(17)
+      expect(a.left(array, 130.5)).to eq(31)
+    end
+
+    it "C.left" do
+      expect(c.left(array, 117)).to eq(17)
+      expect(c.left(array, 130.5)).to eq(31)
+    end
+
+    it "A.right" do
+      expect(a.right(array, 117)).to eq(18)
+      expect(a.right(array, 130.5)).to eq(31)
+    end
+
+    it "C.right" do
+      expect(c.right(array, 117)).to eq(18)
+      expect(c.right(array, 130.5)).to eq(31)
+    end
+  end
+end