unicode_plot 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30cc04427f90664c0157ae18002b8e241cb54d232b33f66edc72b0e6b2dac3d7
-  data.tar.gz: 05c0bfc5b3d2c910bb39f655fb1b10f44c76a552b6e87ede46b4b3f3d04055ca
+  metadata.gz: b33753adec2204f206dff50057dbf735be77c5d1596d8386b103058e76355ba2
+  data.tar.gz: 3209b35c716a2e8293735a6f774185f12c6627996707fb28c59fec3ac02debd7
 SHA512:
-  metadata.gz: 6111ed2d7cc47821286ff5da5a33660c24298a04eaeb56377717aa548b9ba150a4c2b67e0ccf62b4aa36c577413babf0bf7fdc50fd37b6945142628ad0d9ed5a
-  data.tar.gz: 0d11730310f093b679a71ca4bb00b760d10e127030cbe797cbf7a171094e192908a3bb3cf7d9de2ba83527ccd8b60ce8f5dbb1956870741aa4a4f55b5c45ac95
+  metadata.gz: dc5c517d8bdbce3d622767d03e4775365d51ac8a1e882e96d4aaba16c05345c66f0431be9f1eb79ad5cbcbfdfb92e395f06dba5f8f18c8a98b9f93491c25235d
+  data.tar.gz: b5aa69592cf09b140c1dff55edeafbc8204929fe99125dd67d31218286157f4beaa93051da151e5efddcefd24054ec08d458b1aeeee0ac0acabe26813b348b48

data/README.md

@@ -30,7 +30,10 @@ You can get the results below by running the above script:
 
 - barplot
 - boxplot
+- densityplot
+- histogram
 - lineplot
+- scatterplot
 
 ## Acknowledgement
 

data/lib/unicode_plot/ascii_canvas.rb

@@ -1,5 +1,5 @@
 module UnicodePlot
-  class AsciiCanvas < Canvas
+  class AsciiCanvas < LookupCanvas
     ASCII_SIGNS = [
       [ 0b100_000_000, 0b000_100_000, 0b000_000_100 ].freeze,
       [ 0b010_000_000, 0b000_010_000, 0b000_000_010 ].freeze,
@@ -105,47 +105,10 @@ module UnicodePlot
 
     def initialize(width, height, **kw)
       super(width, height,
-            width * PIXEL_PER_CHAR,
-            height * PIXEL_PER_CHAR,
-            0,
-            x_pixel_per_char: PIXEL_PER_CHAR,
-            y_pixel_per_char: PIXEL_PER_CHAR,
+            PIXEL_PER_CHAR, 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 % 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 % 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
-
     def lookup_encode(x, y)
       ASCII_SIGNS[x][y]
     end

data/lib/unicode_plot/barplot.rb

@@ -34,13 +34,19 @@ module UnicodePlot
       @width
     end
 
+    def add_row!(bars)
+      @bars.concat(bars)
+      @max_freq, i = find_max(transform_values(@transform, bars))
+      @max_len = @bars[i].to_s.length
+    end
+
     def print_row(out, row_index)
       check_row_index(row_index)
       bar = @bars[row_index]
       max_bar_width = [width - 2 - max_len, 1].max
       val = transform_values(@transform, bar)
       bar_len = max_freq > 0 ?
-        ([val, 0.0].max.fdiv(max_freq) * max_bar_width).round :
+        ([val, 0].max.fdiv(max_freq) * max_bar_width).round :
         0
       bar_str = max_freq > 0 ? @symbol * bar_len : ""
       bar_lbl = bar.to_s
@@ -81,7 +87,7 @@ module UnicodePlot
                               **kw)
     case args.length
     when 0
-      data = Hash(args[0] || data)
+      data = Hash(data)
       keys = data.keys.map(&:to_s)
       heights = data.values
     when 2
@@ -91,6 +97,13 @@ module UnicodePlot
       raise ArgumentError, "invalid arguments"
     end
 
+    unless keys.length == heights.length
+      raise ArgumentError, "The given vectors must be of the same length"
+    end
+    unless heights.min >= 0
+      raise ArgumentError, "All values have to be positive. Negative bars are not supported."
+    end
+
     xlabel ||= ValueTransformer.transform_name(xscale)
     plot = Barplot.new(heights, width, color, symbol, xscale,
                        border: border, xlabel: xlabel,
@@ -101,4 +114,35 @@ module UnicodePlot
 
     plot
   end
+
+  module_function def barplot!(plot,
+                               *args,
+                               data: nil,
+                               **kw)
+    case args.length
+    when 0
+      data = Hash(data)
+      keys = data.keys.map(&:to_s)
+      heights = data.values
+    when 2
+      keys = Array(args[0])
+      heights = Array(args[1])
+    else
+      raise ArgumentError, "invalid arguments"
+    end
+
+    unless keys.length == heights.length
+      raise ArgumentError, "The given vectors must be of the same length"
+    end
+    if keys.empty?
+      raise ArgumentError, "Can't append empty array to barplot"
+    end
+
+    cur_idx = plot.n_rows
+    plot.add_row!(heights)
+    keys.each_with_index do |key, i|
+      plot.annotate_row!(:l, cur_idx + i, key)
+    end
+    plot
+  end
 end

data/lib/unicode_plot/braille_canvas.rb

@@ -53,7 +53,6 @@ module UnicodePlot
 
     def print_row(out, row_index)
       unless 0 <= row_index && row_index < height
-        $stderr.puts [row_index, height].inspect
         raise ArgumentError, "row_index out of bounds"
       end
       y = row_index

data/lib/unicode_plot/canvas.rb

@@ -8,6 +8,10 @@ module UnicodePlot
         AsciiCanvas.new(width, height, **kw)
       when :braille
         BrailleCanvas.new(width, height, **kw)
+      when :density
+        DensityCanvas.new(width, height, **kw)
+      when :dot
+        DotCanvas.new(width, height, **kw)
       else
         raise ArgumentError, "unknown canvas type: #{canvas_type}"
       end
@@ -22,8 +26,8 @@ module UnicodePlot
                    y_pixel_per_char: 1)
       @width = width
       @height = height
-      @pixel_width = pixel_width
-      @pixel_height = pixel_height
+      @pixel_width = check_positive(pixel_width, :pixel_width)
+      @pixel_height = check_positive(pixel_height, :pixel_height)
       @origin_x = origin_x
       @origin_y = origin_y
       @plot_width = plot_width
@@ -83,7 +87,7 @@ module UnicodePlot
     def point!(x, y, color)
       unless origin_x <= x && x <= origin_x + plot_width &&
              origin_y <= y && y <= origin_y + plot_height
-        return c
+        return color
       end
 
       plot_offset_x = x - origin_x
@@ -156,5 +160,10 @@ module UnicodePlot
         line!(x[i], y[i], x[i+1], y[i+1], color)
       end
     end
+
+    private def check_positive(value, name)
+      return value if value > 0
+      raise ArgumentError, "#{name} has to be positive"
+    end
   end
 end

data/lib/unicode_plot/density_canvas.rb

@@ -0,0 +1,56 @@
+module UnicodePlot
+  class DensityCanvas < Canvas
+    DENSITY_SIGNS = [" ", "░", "▒", "▓", "█"].freeze
+
+    MIN_WIDTH = 5
+    MIN_HEIGHT = 5
+
+    X_PIXEL_PER_CHAR = 1
+    Y_PIXEL_PER_CHAR = 2
+
+    def initialize(width, height, **kw)
+      width = [width, MIN_WIDTH].max
+      height = [height, MIN_HEIGHT].max
+      @max_density = 1
+      super(width, height,
+            width * X_PIXEL_PER_CHAR,
+            height * Y_PIXEL_PER_CHAR,
+            0,
+            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
+
+      char_x = (pixel_x.fdiv(pixel_width) * width).floor
+      char_y = (pixel_y.fdiv(pixel_height) * height).floor
+
+      index = index_at(char_x, char_y)
+      @grid[index] += 1
+      @max_density = [@max_density, @grid[index]].max
+      @colors[index] |= COLOR_ENCODE[color]
+      color
+    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
+      den_sign_count = DENSITY_SIGNS.length
+      val_scale = (den_sign_count - 1).fdiv(@max_density)
+      (0 ... width).each do |x|
+        den_index = (char_at(x, y) * val_scale).round
+        print_color(out, color_at(x, y), DENSITY_SIGNS[den_index])
+      end
+    end
+  end
+end

data/lib/unicode_plot/densityplot.rb

@@ -0,0 +1,10 @@
+module UnicodePlot
+  module_function def densityplot(x, y, color: :auto, grid: false, name: "", **kw)
+    plot = GridPlot.new(x, y, :density, grid: grid, **kw)
+    scatterplot!(plot, x, y, color: color, name: name)
+  end
+
+  module_function def densityplot!(plot, x, y, **kw)
+    scatterplot!(plot, x, y, **kw)
+  end
+end

data/lib/unicode_plot/dot_canvas.rb

@@ -0,0 +1,34 @@
+module UnicodePlot
+  class DotCanvas < LookupCanvas
+    DOT_SIGNS = [
+                  [
+                    0b10,
+                    0b01
+                  ].freeze
+                ].freeze
+
+    DOT_DECODE = [
+      -' ', # 0b00
+      -'.', # 0b01
+      -"'", # 0b10
+      -':', # 0b11
+    ].freeze
+
+    X_PIXEL_PER_CHAR = 1
+    Y_PIXEL_PER_CHAR = 2
+
+    def initialize(width, height, **kw)
+      super(width, height,
+            X_PIXEL_PER_CHAR, Y_PIXEL_PER_CHAR,
+            **kw)
+    end
+
+    def lookup_encode(x, y)
+      DOT_SIGNS[x][y]
+    end
+
+    def lookup_decode(code)
+      DOT_DECODE[code]
+    end
+  end
+end

data/lib/unicode_plot/grid_plot.rb

@@ -0,0 +1,101 @@
+module UnicodePlot
+  class GridPlot < 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)
+      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
+      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
+end

data/lib/unicode_plot/histogram.rb

@@ -0,0 +1,48 @@
+require 'enumerable/statistics'
+
+module UnicodePlot
+  module_function def histogram(x,
+                                nbins: nil,
+                                closed: :left,
+                                symbol: "▇",
+                                **kw)
+    hist = x.histogram(*[nbins].compact, closed: closed)
+    edge, counts = hist.edge, hist.weights
+    labels = []
+    bin_width = edge[1] - edge[0]
+    pad_left, pad_right = 0, 0
+    (0 ... edge.length).each do |i|
+      val1 = Utils.float_round_log10(edge[i], bin_width)
+      val2 = Utils.float_round_log10(val1 + bin_width, bin_width)
+      a1 = val1.to_s.split('.', 2).map(&:length)
+      a2 = val2.to_s.split('.', 2).map(&:length)
+      pad_left  = [pad_left,  a1[0], a2[0]].max
+      pad_right = [pad_right, a1[1], a2[1]].max
+    end
+    l_str = hist.closed == :right ? "(" : "["
+    r_str = hist.closed == :right ? "]" : ")"
+    counts.each_with_index do |n, i|
+      val1 = Utils.float_round_log10(edge[i], bin_width)
+      val2 = Utils.float_round_log10(val1 + bin_width, bin_width)
+      a1 = val1.to_s.split('.', 2).map(&:length)
+      a2 = val2.to_s.split('.', 2).map(&:length)
+      labels[i] = "\e[90m#{l_str}\e[0m" +
+                  (" " * (pad_left - a1[0])) +
+                  val1.to_s +
+                  (" " * (pad_right - a1[1])) +
+                  "\e[90m, \e[0m" +
+                  (" " * (pad_left - a2[0])) +
+                  val2.to_s +
+                  (" " * (pad_right - a2[1])) +
+                  "\e[90m#{r_str}\e[0m"
+    end
+    xscale = kw.delete(:xscale)
+    xlabel = kw.delete(:xlabel) ||
+             ValueTransformer.transform_name(xscale, "Frequency")
+    barplot(labels, counts,
+            symbol: symbol,
+            xscale: xscale,
+            xlabel: xlabel,
+            **kw)
+  end
+end