unicode_plot 0.0.2 → 0.0.3

data/lib/unicode_plot/lineplot.rb

@@ -1,111 +1,7 @@
 require 'date'
 
 module UnicodePlot
-  class GridCanvas < Plot
-    MIN_WIDTH = 5
-    DEFAULT_WIDTH = 40
-    MIN_HEIGHT = 2
-    DEFAULT_HEIGHT = 15
-
-    def initialize(x, y, canvas,
-                   width: DEFAULT_WIDTH,
-                   height: DEFAULT_HEIGHT,
-                   xlim: [0, 0], 
-                   ylim: [0, 0],
-                   grid: true,
-                   **kw)
-      unless xlim.length == 2 && ylim.length == 2
-        raise ArgumentError, "xlim and ylim must be 2-length arrays"
-      end
-      width = [width, MIN_WIDTH].max
-      height = [height, MIN_HEIGHT].max
-      min_x, max_x = Utils.extend_limits(x, xlim)
-      min_y, max_y = Utils.extend_limits(y, ylim)
-      origin_x = min_x
-      origin_y = min_y
-      plot_width = max_x - origin_x
-      plot_height = max_y - origin_y
-      @canvas = Canvas.create(canvas, width, height,
-                              origin_x: origin_x,
-                              origin_y: origin_y,
-                              plot_width: plot_width,
-                              plot_height: plot_height)
-      super(**kw)
-
-      min_x_str = (Utils.roundable?(min_x) ? min_x.round : min_x).to_s
-      max_x_str = (Utils.roundable?(max_x) ? max_x.round : max_x).to_s
-      min_y_str = (Utils.roundable?(min_y) ? min_y.round : min_y).to_s
-      max_y_str = (Utils.roundable?(max_y) ? max_y.round : max_y).to_s
-
-      annotate_row!(:l, 0, max_y_str, color: :light_black)
-      annotate_row!(:l, height-1, min_y_str, color: :light_black)
-      annotate!(:bl, min_x_str, color: :light_black)
-      annotate!(:br, max_x_str, color: :light_black)
-
-      if grid
-        if min_y < 0 && 0 < max_y
-          step = plot_width.fdiv(width * @canvas.x_pixel_per_char - 1)
-          min_x.step(max_x, by: step) do |i|
-            @canvas.point!(i, 0, :normal)
-          end
-        end
-        if min_x < 0 && 0 < max_x
-          step = plot_height.fdiv(height * @canvas.y_pixel_per_char - 1)
-          min_y.step(max_y, by: step) do |i|
-            @canvas.point!(0, i, :normal)
-          end
-        end
-      end
-    end
-
-    def origin_x
-      @canvas.origin_x
-    end
-
-    def origin_y
-      @canvas.origin_y
-    end
-
-    def plot_width
-      @canvas.plot_width
-    end
-
-    def plot_height
-      @canvas.plot_height
-    end
-
-    def n_rows
-      @canvas.height
-    end
-
-    def n_columns
-      @canvas.width
-    end
-
-    def points!(x, y, color)
-      @canvas.points!(x, y, color)
-    end
-
-    def lines!(x, y, color)
-      @canvas.lines!(x, y, color)
-    end
-
-    def print_row(out, row_index)
-      @canvas.print_row(out, row_index)
-    end
-  end
-
-  class Lineplot < GridCanvas
-    def initialize(x, y, canvas,
-                   **kw)
-      if x.length != y.length
-        raise ArgumentError, "x and y must be the same length"
-      end
-      unless x.length > 0
-        raise ArgumentError, "x and y must not be empty"
-      end
-      super(x, y, canvas, **kw)
-    end
+  class Lineplot < GridPlot
   end
 
   module_function def lineplot(*args,

data/lib/unicode_plot/lookup_canvas.rb

@@ -0,0 +1,46 @@
+module UnicodePlot
+  class LookupCanvas < Canvas
+    def initialize(width, height, x_pixel_per_char, y_pixel_per_char, fill_char=0, **kw)
+      super(width, height,
+            width * x_pixel_per_char,
+            height * y_pixel_per_char,
+            fill_char,
+            x_pixel_per_char: x_pixel_per_char,
+            y_pixel_per_char: y_pixel_per_char,
+            **kw)
+    end
+
+    def pixel!(pixel_x, pixel_y, color)
+      unless 0 <= pixel_x && pixel_x <= pixel_width &&
+             0 <= pixel_y && pixel_y <= pixel_height
+        return color
+      end
+      pixel_x -= 1 unless pixel_x < pixel_width
+      pixel_y -= 1 unless pixel_y < pixel_height
+
+      tx = pixel_x.fdiv(pixel_width) * width
+      char_x = tx.floor + 1
+      char_x_off = pixel_x % x_pixel_per_char + 1
+      char_x += 1 if char_x < tx.round + 1 && char_x_off == 1
+
+      char_y = (pixel_y.fdiv(pixel_height) * height).floor + 1
+      char_y_off = pixel_y % y_pixel_per_char + 1
+
+      index = index_at(char_x - 1, char_y - 1)
+      if index
+        @grid[index] |= lookup_encode(char_x_off - 1, char_y_off - 1)
+        @colors[index] |= COLOR_ENCODE[color]
+      end
+    end
+
+    def print_row(out, row_index)
+      unless 0 <= row_index && row_index < height
+        raise ArgumentError, "row_index out of bounds"
+      end
+      y = row_index
+      (0 ... width).each do |x|
+        print_color(out, color_at(x, y), lookup_decode(char_at(x, y)))
+      end
+    end
+  end
+end

data/lib/unicode_plot/renderer.rb

@@ -124,8 +124,8 @@ module UnicodePlot
       left_col  = plot.colors_left.fetch(row, :light_black)
       right_str = plot.labels_right.fetch(row, "")
       right_col = plot.colors_right.fetch(row, :light_black)
-      left_len  = left_str.length
-      right_len = right_str.length
+      left_len  = nocolor_string(left_str).length
+      right_len = nocolor_string(right_str).length
 
       unless color?(out)
         left_str  = nocolor_string(left_str)
@@ -201,10 +201,10 @@ module UnicodePlot
 
       # get length of largest strings to the left and right
       @max_len_l = plot.show_labels? && !plot.labels_left.empty? ?
-        plot.labels_left.each_value.map {|l| l.to_s.length }.max :
+        plot.labels_left.each_value.map {|l| nocolor_string(l).length }.max :
         0
       @max_len_r = plot.show_labels? && !plot.labels_right.empty? ?
-        plot.labels_right.each_value.map {|l| l.to_s.length }.max :
+        plot.labels_right.each_value.map {|l| nocolor_string(l).length }.max :
         0
       if plot.show_labels? && plot.ylabel_given?
         @max_len_l += plot.ylabel_length + 1
@@ -220,7 +220,7 @@ module UnicodePlot
       @border_padding = " " * @plot_offset
 
       # compute position of ylabel
-      @y_lab_row = (plot.n_rows / 2.0).round
+      @y_lab_row = (plot.n_rows / 2.0).round - 1
     end
 
     def print_title(padding, title, p_width: 0, color: :normal)

data/lib/unicode_plot/scatterplot.rb

@@ -0,0 +1,49 @@
+module UnicodePlot
+  class Scatterplot < GridPlot
+  end
+
+  module_function def scatterplot(*args,
+                                  canvas: :braille,
+                                  color: :auto,
+                                  name: "",
+                                  **kw)
+    case args.length
+    when 1
+      # y only
+      y = Array(args[0])
+      x = Array(1 .. y.length)
+    when 2
+      # x and y
+      x = Array(args[0])
+      y = Array(args[1])
+    else
+      raise ArgumentError, "worng number of arguments"
+    end
+
+    plot = Scatterplot.new(x, y, canvas, **kw)
+    scatterplot!(plot, x, y, color: color, name: name)
+  end
+
+  module_function def scatterplot!(plot,
+                                   *args,
+                                   color: :auto,
+                                   name: "")
+    case args.length
+    when 1
+      # y only
+      y = Array(args[0])
+      x = Array(1 .. y.length)
+    when 2
+      # x and y
+      x = Array(args[0])
+      y = Array(args[1])
+    else
+      raise ArgumentError, "worng number of arguments"
+    end
+
+    color = color == :auto ? plot.next_color : color
+    plot.annotate!(:r, name.to_s, color: color) unless name.nil? || name == ""
+    plot.points!(x, y, color)
+    plot
+  end
+end

data/lib/unicode_plot/utils.rb

@@ -26,6 +26,16 @@ module UnicodePlot
       [xmin.to_f, xmax.to_f]
     end
 
+    def float_round_log10(x, m)
+      if x == 0
+        0.0
+      elsif x > 0
+        x.round(ceil_neg_log10(m) + 1).to_f
+      else
+        -(-x).round(ceil_neg_log10(m) + 1).to_f
+      end
+    end
+
     def round_up_subtick(x, m)
       if x == 0
         0.0
@@ -54,8 +64,11 @@ module UnicodePlot
       end
     end
 
+    INT64_MIN = -9223372036854775808
+    INT64_MAX =  9223372036854775807
+
     def roundable?(x)
-      x.to_i == x
+      x.to_i == x && INT64_MIN <= x && x < INT64_MAX
     end
   end
 end

data/lib/unicode_plot/version.rb

@@ -1,5 +1,5 @@
 module UnicodePlot
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
   module Version
     numbers, TAG = VERSION.split("-", 2)

data/lib/unicode_plot.rb

@@ -6,11 +6,18 @@ require 'unicode_plot/value_transformer'
 require 'unicode_plot/renderer'
 
 require 'unicode_plot/canvas'
-require 'unicode_plot/ascii_canvas'
 require 'unicode_plot/braille_canvas'
+require 'unicode_plot/density_canvas'
+require 'unicode_plot/lookup_canvas'
+require 'unicode_plot/ascii_canvas'
+require 'unicode_plot/dot_canvas'
 
 require 'unicode_plot/plot'
+require 'unicode_plot/grid_plot'
 
 require 'unicode_plot/barplot'
 require 'unicode_plot/boxplot'
+require 'unicode_plot/densityplot'
 require 'unicode_plot/lineplot'
+require 'unicode_plot/histogram'
+require 'unicode_plot/scatterplot'

data/test/test-barplot.rb

@@ -3,30 +3,46 @@ class BarplotTest < Test::Unit::TestCase
   include Helper::WithTerm
 
   sub_test_case("UnicodePlot.barplot") do
-    sub_test_case("print to tty") do
-      test("the output is colored") do
-        data = { bar: 23, foo: 37 }
-        plot = UnicodePlot.barplot(data: data)
-        _, output = with_term do
-          plot.render($stdout)
-        end
-        assert_equal(fixture_path("barplot/default.txt").read,
-                     output)
+    test("errors") do
+      assert_raise(ArgumentError) do
+        UnicodePlot.barplot([:a], [-1, 2])
+      end
+      assert_raise(ArgumentError) do
+        UnicodePlot.barplot([:a, :b], [-1, 2])
       end
     end
 
-    sub_test_case("print to non-tty IO") do
-      test("the output is not colored") do
-        data = { bar: 23, foo: 37 }
-        plot = UnicodePlot.barplot(data: data)
-        output = StringIO.open do |sio|
-          sio.print(plot)
-          sio.close
-          sio.string
-        end
-        assert_equal(fixture_path("barplot/nocolor.txt").read,
-                     output)
+    test("colored") do
+      data = { bar: 23, foo: 37 }
+      plot = UnicodePlot.barplot(data: data)
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default.txt").read,
+                   output)
+
+      plot = UnicodePlot.barplot([:bar, :foo], [23, 37])
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default.txt").read,
+                   output)
+    end
+
+    test("not colored") do
+      data = { bar: 23, foo: 37 }
+      plot = UnicodePlot.barplot(data: data)
+      output = StringIO.open do |sio|
+        sio.print(plot)
+        sio.close
+        sio.string
       end
+      assert_equal(fixture_path("barplot/nocolor.txt").read,
+                   output)
+    end
+
+    test("mixed") do
+      data = { bar: 23.0, 2.1 => 10, foo: 37.0 }
+      plot = UnicodePlot.barplot(data: data)
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default_mixed.txt").read,
+                   output)
     end
 
     sub_test_case("xscale: :log10") do
@@ -55,5 +71,120 @@ class BarplotTest < Test::Unit::TestCase
                      output)
       end
     end
+
+    sub_test_case("with parameters") do
+      test("parameters1") do
+        plot = UnicodePlot.barplot(
+          ["Paris", "New York", "Moskau", "Madrid"],
+          [2.244, 8.406, 11.92, 3.165],
+          title: "Relative sizes of cities",
+          xlabel: "population [in mil]",
+          color: :blue,
+          margin: 7,
+          padding: 3
+        )
+        _, output = with_term { plot.render($stdout) }
+        assert_equal(fixture_path("barplot/parameters1.txt").read,
+                     output)
+      end
+
+      test("parameters1_nolabels") do
+        plot = UnicodePlot.barplot(
+          ["Paris", "New York", "Moskau", "Madrid"],
+          [2.244, 8.406, 11.92, 3.165],
+          title: "Relative sizes of cities",
+          xlabel: "population [in mil]",
+          color: :blue,
+          margin: 7,
+          padding: 3,
+          labels: false
+        )
+        _, output = with_term { plot.render($stdout) }
+        assert_equal(fixture_path("barplot/parameters1_nolabels.txt").read,
+                     output)
+      end
+
+      test("parameters2") do
+        plot = UnicodePlot.barplot(
+          ["Paris", "New York", "Moskau", "Madrid"],
+          [2.244, 8.406, 11.92, 3.165],
+          title: "Relative sizes of cities",
+          xlabel: "population [in mil]",
+          color: :yellow,
+          border: :solid,
+          symbol: "=",
+          width: 60
+        )
+        _, output = with_term { plot.render($stdout) }
+        assert_equal(fixture_path("barplot/parameters2.txt").read,
+                     output)
+      end
+    end
+
+    test("ranges") do
+      plot = UnicodePlot.barplot(2..6, 11..15)
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/ranges.txt").read,
+                   output)
+    end
+
+    test("all zeros") do
+      plot = UnicodePlot.barplot([5, 4, 3, 2, 1], [0, 0, 0, 0, 0])
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/edgecase_zeros.txt").read,
+                   output)
+    end
+
+    test("one large") do
+      plot = UnicodePlot.barplot([:a, :b, :c, :d], [1, 1, 1, 1000000])
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/edgecase_onelarge.txt").read,
+                   output)
+    end
+  end
+
+  sub_test_case("UnicodePlot.barplot!") do
+    test("errors") do
+      plot = UnicodePlot.barplot([:bar, :foo], [23, 37])
+      assert_raise(ArgumentError) do
+        UnicodePlot.barplot!(plot, ["zoom"], [90, 80])
+      end
+      assert_raise(ArgumentError) do
+        UnicodePlot.barplot!(plot, ["zoom", "boom"], [90])
+      end
+      UnicodePlot.barplot!(plot, "zoom", 90.1)
+    end
+
+    test("return value") do
+      plot = UnicodePlot.barplot([:bar, :foo], [23, 37])
+      assert_same(plot,
+                  UnicodePlot.barplot!(plot, ["zoom"], [90]))
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default2.txt").read,
+                   output)
+
+      plot = UnicodePlot.barplot([:bar, :foo], [23, 37])
+      assert_same(plot,
+                  UnicodePlot.barplot!(plot, "zoom", 90))
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default2.txt").read,
+                   output)
+
+      plot = UnicodePlot.barplot([:bar, :foo], [23, 37])
+      assert_same(plot,
+                  UnicodePlot.barplot!(plot, data: { zoom: 90 }))
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/default2.txt").read,
+                   output)
+    end
+
+    test("ranges") do
+      plot = UnicodePlot.barplot(2..6, 11..15)
+      assert_same(plot,
+                  UnicodePlot.barplot!(plot, 9..10, 20..21))
+      _, output = with_term { plot.render($stdout) }
+      assert_equal(fixture_path("barplot/ranges2.txt").read,
+                   output)
+    end
   end
 end