ruby-gr 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f31069eac6089014b6cbea3453d5c7e42996e02b1b243e0b8d3aa116fb1b3c3f
-  data.tar.gz: 697465b25729e4f7a8b9b8c6252b3ceec4e6614f5760994cb91a2a8ad31d34df
+  metadata.gz: 55e5471b8532f7e180f80572158336cecc130575626a2b3361bd7ce6b0454bef
+  data.tar.gz: d7387d744d28cb389a44769df8b9d477adc2a1320f73f8d02c55ffc17d1b1a02
 SHA512:
-  metadata.gz: 74496ad16167dfba8725c67f65b20125f00d1969a0c311e1e9312be465e740c303df9482671c61d04c2de77773208ac8cfb6e33c301f33173ce27fe21540d9f0
-  data.tar.gz: 0c5ee85a6944438ea3f0b0ecfc61ef1f188a4c779205d84eb2bce63b83746fe36ee57c94d402235bb020189d526f03e6d9f1828253da181bd95307fcaf8e0b5e
+  metadata.gz: 1d13f13cb5e85843ab006b0ea1ce8a6d400edceb0b5f69ac8bf86eb5a756ce8c2dfed5ebbf7c0ecddc07ef48fba948528c53df77bf6899664098f76c8fbdb282
+  data.tar.gz: 7f1d0091163902cb52acd7f3e0fab91cc15e178a0c39be8476e05397a8f9b6de9aad25211f4e9cb2e04ee199ebf51a6a78d8d3afbc89781743c616c74fa6a8fb

data/README.md

@@ -36,7 +36,7 @@ require 'gr/plot'
 x = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
 y = [0.3, 0.5, 0.4, 0.2, 0.6, 0.7]
 
-GR.lineplot(x, y)
+GR.plot(x, y)
 ```
 
 ## Examples

data/lib/gr/plot.rb

@@ -20,7 +20,7 @@ module GR
     # So, you will see many if branches here.
     # This is not the Ruby code style. But it WORKS.
     #
-    # I want to thank the Josef Heinen(@jheinen), the creator of GR.jl
+    # I want to thank Josef Heinen(@jheinen), the creator of GR.jl
     # and Florian Rhiem(@FlorianRhiem), the creator of python-gr.
     #
     # If you are interested in an object-oriented implementation,
@@ -190,7 +190,7 @@ module GR
       kvs[:xaxis] = xtick, xorg, majorx
 
       ymin, ymax = kvs[:yrange]
-      if kind == :hist && kvs.key?(:ylim)
+      if kind == :hist && !kvs.key?(:ylim)
         ymin = (scale & GR::OPTION_Y_LOG) == 0 ? 0 : 1
       end
       if (scale & GR::OPTION_Y_LOG) == 0
@@ -669,9 +669,14 @@ module GR
           draw_polar_axes
           kvs[:zrange] = [cmin, cmax]
           colorbar
-        when :contour
+        when :contour, :contourf
           zmin, zmax = kvs[:zrange]
-          if x.length == y.length && y.length == z.length
+          if narray?(z) && z.ndim == 2
+            a, b = z.shape
+            x = (1..b).to_a
+            y = (1..a).to_a
+            zmin, zmax = kvs[:zlim] || z.minmax
+          elsif equal_length(x, y, z)
             x, y, z = GR.gridit(x, y, z, 200, 200)
             zmin, zmax = kvs[:zlim] || z.compact.minmax # compact : removed nil
           end
@@ -684,28 +689,15 @@ module GR
           else
             h = levels
           end
-          GR.contour(x, y, h, z, clabels ? 1 : 1000)
-          colorbar(0, h.length)
-        when :contourf
-          zmin, zmax = kvs[:zrange]
-          if x.length == y.length && y.length == z.length
-            x, y, z = GR.gridit(x, y, z, 200, 200)
-            zmin, zmax = kvs[:zlim] || z.compact.minmax # compact : removed nil
-          end
-          GR.setspace(zmin, zmax, 0, 90)
-          levels = kvs[:levels] || 0
-          clabels = kvs[:clabels] || false
-          if levels.is_a? Integer
-            hmin, hmax = GR.adjustrange(zmin, zmax)
-            h = linspace(hmin, hmax, levels == 0 ? 21 : levels + 1)
-          else
-            h = levels
+          if kind == :contour
+            GR._contour_(x, y, h, z, clabels ? 1 : 1000)
+          elsif kind == :contourf
+            GR._contourf_(x, y, h, z, clabels ? 1 : 0)
           end
-          GR.contourf(x, y, h, z, clabels ? 1 : 0)
           colorbar(0, h.length)
         when :hexbin
           nbins = kvs[:nbins] || 40
-          cntmax = GR.hexbin(x, y, nbins)
+          cntmax = GR._hexbin_(x, y, nbins)
           if cntmax > 0
             kvs[:zrange] = [0, cntmax]
             colorbar
@@ -737,14 +729,26 @@ module GR
           end
           colorbar(0, levels)
         when :wireframe
-          x, y, z = GR.gridit(x, y, z, 50, 50) if equal_length(x, y, z)
+          if narray?(z) && z.ndim == 2
+            a, b = z.shape
+            x = (1..b).to_a
+            y = (1..a).to_a
+          elsif equal_length(x, y, z)
+            x, y, z = GR.gridit(x, y, z, 50, 50)
+          end
           GR.setfillcolorind(0)
-          GR.surface(x, y, z, GR::OPTION_FILLED_MESH)
+          GR._surface_(x, y, z, GR::OPTION_FILLED_MESH)
           draw_axes(kind, 2)
         when :surface
-          x, y, z = GR.gridit(x, y, z, 200, 200) if equal_length(x, y, z)
+          if narray?(z) && z.ndim == 2
+            a, b = z.shape
+            x = (1..b).to_a
+            y = (1..a).to_a
+          elsif equal_length(x, y, z)
+            x, y, z = GR.gridit(x, y, z, 200, 200)
+          end
           if kvs[:accelerate] == false
-            GR.surface(x, y, z, GR::OPTION_COLORED_MESH)
+            GR._surface_(x, y, z, GR::OPTION_COLORED_MESH)
           else
             require 'gr3'
             GR3.clear
@@ -785,13 +789,13 @@ module GR
           GR.uselinespec(spec)
           plot_polar(x, y)
         when :trisurf
-          GR.trisurface(x, y, z)
+          GR._trisurface_(x, y, z)
           draw_axes(kind, 2)
           colorbar(0.05)
         when :tricont
           zmin, zmax = kvs[:zrange]
           levels = linspace(zmin, zmax, 20)
-          GR.tricontour(x, y, z, levels)
+          GR._tricontour_(x, y, z, levels)
         when :shade
           xform = kvs[:xform] || 5
           if x.to_a.include? Float::NAN # FIXME: Ruby is different from Julia?
@@ -1078,42 +1082,33 @@ module GR
   end
 
   class << self
-    def lineplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.plot_data
+    # line plot
+    def plot(*args)
+      create_plot(:line, *args)
     end
 
-    def stepplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :step
-      plt.plot_data
+    def step(*args)
+      create_plot(:step, *args)
     end
 
-    def scatterplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :scatter
-      plt.plot_data
+    def scatter(*args)
+      create_plot(:scatter, *args)
     end
 
-    def scatterplot3(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :scatter3
-      plt.plot_data
+    def scatter3(*args)
+      create_plot(:scatter3, *args)
     end
 
-    def stemplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :stem
-      plt.plot_data
+    def stem(*args)
+      create_plot(:stem, *args)
     end
 
     def histogram(x, kv = {})
-      plt = GR::Plot.new(x, kv)
-      plt.kvs[:kind] = :hist
-      nbins = plt.kvs[:nbins] || 0
-      x, y = hist(x, nbins)
-      plt.args = [[x, y, nil, nil, '']]
-      plt.plot_data
+      create_plot(:hist, x, kv) do |plt|
+        nbins = plt.kvs[:nbins] || 0
+        x, y = hist(x, nbins)
+        plt.args = [[x, y, nil, nil, '']]
+      end
     end
 
     # def polarhistogram(x, kv = {})
@@ -1126,19 +1121,15 @@ module GR
     # end
 
     def heatmap(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :heatmap
       # FIXME
-      if narray?(args.first)
-        z = args.first
-        width, height = z.shape
-        plt.kvs[:xlim] ||= [0.5, width + 0.5]
-        plt.kvs[:ylim] ||= [0.5, height + 0.5]
-        plt.args = [[[*1..width], [*1..height], z, nil, '']]
-      else
-        raise 'not implemented'
+      _x, _y, z, kv = parse_args(*args)
+      ysize, xsize = z.shape
+      z = z.reshape(xsize, ysize)
+      create_plot(:heatmap, kv) do |plt|
+        plt.kvs[:xlim] ||= [0.5, xsize + 0.5]
+        plt.kvs[:ylim] ||= [0.5, ysize + 0.5]
+        plt.args = [[(1..xsize).to_a, (1..ysize).to_a, z, nil, '']]
       end
-      plt.plot_data
     end
 
     def polarheatmap(*args)
@@ -1147,184 +1138,144 @@ module GR
       z = Numo::DFloat.cast(d)
       raise 'expected 2-D array' unless z.ndim == 2
 
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :polarheatmap
-      width, height = z.shape
-      plt.kvs[:xlim] ||= [0.5, width + 0.5]
-      plt.kvs[:ylim] ||= [0.5, height + 0.5]
-      plt.args = [[(1..width).to_a, (1..height).to_a, z, nil, '']]
-      plt.plot_data
+      create_plot(:polarheatmap, z, *args) do |plt|
+        width, height = z.shape
+        plt.kvs[:xlim] ||= [0.5, width + 0.5]
+        plt.kvs[:ylim] ||= [0.5, height + 0.5]
+        plt.args = [[(1..width).to_a, (1..height).to_a, z, nil, '']]
+      end
     end
 
-    def contourplot(*args)
-      kv = if args[-1].is_a? Hash
-             args.pop
-           else
-             {}
-           end
-      if args.size == 1
-        if args[0].is_a? Array
-          z = Numo::DFloat.cast(args[0])
-          xsize, ysize = z.shape
-        elsif narray?(args[0])
-          z = args[0]
-          xsize, ysize = z.shape
-        end
-        x = (1..xsize).to_a
-        y = (1..ysize).to_a
-      elsif args.size == 3
-        x, y, z = args
-      else
-        raise
-      end
-      plt = GR::Plot.new(x, y, z, kv)
-      plt.kvs[:kind] = :contour
-      plt.plot_data
+    alias _contour_ contour
+    def contour(*args)
+      x, y, z, kv = parse_args(*args)
+      create_plot(:contour, x, y, z, kv)
     end
 
-    def contourfplot(*args)
-      kv = if args[-1].is_a? Hash
-             args.pop
-           else
-             {}
-           end
-      if args.size == 1
-        if args[0].is_a? Array
-          z = Numo::DFloat.cast(args[0])
-          xsize, ysize = z.shape
-        elsif narray?(args[0])
-          z = args[0]
-          xsize, ysize = z.shape
-        end
-        x = (1..xsize).to_a
-        y = (1..ysize).to_a
-      elsif args.size == 3
-        x, y, z = args
-      else
-        raise
-      end
-      plt = GR::Plot.new(x, y, z, kv)
-      plt.kvs[:kind] = :contourf
-      plt.plot_data
+    alias _contourf_ contourf
+    def contourf(*args)
+      x, y, z, kv = parse_args(*args)
+      create_plot(:contourf, x, y, z, kv)
     end
 
-    def hexbinplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :hexbin
-      plt.plot_data
+    alias _hexbin_ hexbin
+    def hexbin(*args)
+      create_plot(:hexbin, *args)
     end
 
-    def tricontourplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :tricont
-      plt.plot_data
+    alias _tricontour_ tricontour
+    def tricontour(*args)
+      create_plot(:tricont, *args)
     end
 
-    def surfaceplot(*args)
-      kv = if args[-1].is_a? Hash
-             args.pop
-           else
-             {}
-           end
-      if args.size == 1
-        if args[0].is_a? Array
-          z = Numo::DFloat.cast(args[0])
-          xsize, ysize = z.shape
-        elsif narray?(args[0])
-          z = args[0]
-          xsize, ysize = z.shape
-        end
-        x = ([(1..xsize).to_a] * ysize).flatten
-        y = ((1..ysize).to_a.map { |i| [i] * xsize }).flatten
-      elsif args.size == 3
-        x, y, z = args
-      else
-        raise
-      end
-      plt = GR::Plot.new(x, y, z, kv)
-      plt.kvs[:kind] = :surface
-      plt.plot_data
+    alias _surface_ surface
+    def surface(*args)
+      x, y, z, kv = parse_args(*args)
+      create_plot(:surface, x, y, z, kv)
     end
 
-    def polarplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :polar
-      plt.plot_data
+    def polar(*args)
+      create_plot(:polar, *args)
     end
 
-    def trisurfaceplot(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :trisurf
-      plt.plot_data
+    alias _trisurface_ trisurface
+    def trisurface(*args)
+      create_plot(:trisurf, *args)
     end
 
     def wireframe(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :wireframe
-      plt.plot_data
+      create_plot(:wireframe, *args)
     end
 
-    def lineplot3(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :plot3
-      plt.plot_data
+    def plot3(*args)
+      create_plot(:plot3, *args)
     end
 
-    # Note: GR.shade exists
+    alias _shade_ shade
     def shade(*args)
-      plt = GR::Plot.new(*args)
-      plt.kvs[:kind] = :shade
-      plt.plot_data
+      create_plot(:shade, *args)
     end
 
-    def volumeplot(v, kv = {})
-      plt = GR::Plot.new(v, kv)
-      plt.kvs[:kind] = :volume
-      plt.args = [[nil, nil, v, nil, '']]
-      plt.plot_data
+    def volume(v, kv = {})
+      create_plot(:volume, v, kv) do |plt|
+        plt.args = [[nil, nil, v, nil, '']]
+      end
     end
 
     def barplot(labels, heights, kv = {})
+      labels = labels.map(&:to_s)
       wc, hc = barcoordinates(heights)
       horizontal = kv[:horizontal] || false
-      plt = GR::Plot.new(labels, heights, kv)
-      plt.kvs[:kind] = :bar
-      if horizontal
-        plt.args = [[hc, wc, nil, nil, '']]
-        plt.kvs[:yticks] = [1, 1]
-        plt.kvs[:yticklabels] = labels
-      else
-        plt.args = [[wc, hc, nil, nil, '']]
-        plt.kvs[:xticks] = [1, 1]
-        plt.kvs[:xticklabels] = labels
+      create_plot(:bar, labels, heights, kv) do |plt|
+        if horizontal
+          plt.args = [[hc, wc, nil, nil, '']]
+          plt.kvs[:yticks] = [1, 1]
+          plt.kvs[:yticklabels] = labels
+        else
+          plt.args = [[wc, hc, nil, nil, '']]
+          plt.kvs[:xticks] = [1, 1]
+          plt.kvs[:xticklabels] = labels
+        end
       end
-      plt.plot_data
     end
 
     def imshow(img, kv = {})
       img = Numo::DFloat.cast(img) # Umm...
-      plt = GR::Plot.new(kv)
-      plt.kvs[:kind] = :imshow
-      plt.args = [[nil, nil, img, nil, '']]
-      plt.plot_data
+      create_plot(:imshow, img, kv) do |plt|
+        plt.args = [[nil, nil, img, nil, '']]
+      end
     end
 
     def isosurface(v, kv = {})
       v = Numo::DFloat.cast(v) # Umm...
-      plt = GR::Plot.new(kv)
-      plt.kvs[:kind] = :isosurface
-      plt.args = [[nil, nil, v, nil, '']]
-      plt.plot_data
+      create_plot(:isosurface, v, kv) do |plt|
+        plt.args = [[nil, nil, v, nil, '']]
+      end
     end
 
     private
 
+    def create_plot(type, *args, &block)
+      plt = GR::Plot.new(*args)
+      plt.kvs[:kind] = type
+      block.call(plt) if block_given?
+      plt.plot_data
+    end
+
+    def parse_args(*args)
+      kv = if args[-1].is_a? Hash
+             args.pop
+           else
+             {}
+           end
+      if args.size == 1
+        if args[0].is_a? Array
+          z = Numo::DFloat.cast(args[0])
+        elsif narray?(args[0])
+          z = args[0]
+        end
+        xsize, ysize = z.shape
+        # NOTE:
+        # See
+        # https://github.com/jheinen/GR.jl/pull/246
+        # https://github.com/jheinen/GR.jl/issues/241
+        x = (1..ysize).to_a * xsize
+        y = (1..xsize).map { |i| Array.new(ysize, i) }.flatten
+
+      elsif args.size == 3
+        x, y, z = args
+      else
+        raise
+      end
+      [x, y, z, kv]
+    end
+
     def hist(x, nbins = 0)
       nbins = (3.3 * Math.log10(x.length)).round + 1 if nbins <= 1
       require 'histogram/array' # dependency
       x = x.to_a if narray?(x)
       x, y = x.histogram(nbins, bin_boundary: :min)
-      x.unshift(x.min)
+      x.push(x[-1] + x[1] - x[0])
       [x, y]
     end
 

data/lib/gr/plot.rb.md

@@ -72,82 +72,60 @@ module GR
     def plot_args; end # should be private?
 
     # Draw one or more line plots.
-    def plot_line; end
-    alias lineplot plot_line
+    def plot; end
 
     # def plot_line_over oplot_line ?
 
     # Draw one or more step or staircase plots.
-    def plot_step; end
-    alias stepplot plot_step
-    alias step plot_step
+    def step; end
 
     # Draw one or more scatter plots.
-    def plot_scatter; end
-    alias scatterplot plot_scatter
-    alias scatter plot_scatter
+    def scatter; end
 
     # Draw a stem plot.
-    def plot_stem; end
-    alias stemplot plot_stem
-    alias stem plot_stem
+    def stem; end
 
     # Draw a bar plot.
-    def plot_bar; end
-    alias barplot plot_bar
-    alias bar plot_bar
+    def barplot; end
 
     def hist; end # should be private?
 
     # Draw a histogram.
-    def plot_histgram; end
-    alias histogram plot_histgram
+    def histgram; end
 
     # Draw a polar histogram.
-    def plot_polarhistogram; end
-    alias polarhistogram plot_polarhistogram
+    def polarhistogram; end
 
     # Draw a contour plot.
-    def plot_contour; end
-    alias contourplot plot_contour
+    def contour; end
     # GR.contour is already defined in GR::FFI class.
 
     # Draw a filled contour plot.
-    def plot_contourf; end
-    alias contourfplot plot_contour # change name?
+    def contourf; end
     # GR.contourf is already defined in GR::FFI class.
 
     # Draw a hexagon binning plot.
-    def plot_hexbin; end
-    alias hexbinplot plot_hexbin
+    def hexbin; end
     # GR.hexbin is already defined in GR::FFI class.
-    alias jointplot plot_hexbin
 
     # Draw a heatmap.
-    def plot_heatmap; end
-    alias heatmap plot_heatmap
+    def heatmap; end
 
-    def plot_polarheatmap; end
-    alias polarheatmap plot_polarheatmap
+    def polarheatmap; end
 
     # Draw a three-dimensional wireframe plot.
-    def plot_wireframe; end
-    alias wireframe plot_wireframe
+    def wireframe; end
 
     # Draw a three-dimensional surface plot.
-    def plot_surface; end
-    alias surfaceplot plot_surface
+    def surface; end
 
-    def plot_volume; end
-    alias volumeplot plot_volume
+    def volume; end
 
     # Draw one or more three-dimensional line plots.
-    def plot_line3; end
-    alias lineplot3 plot_line3
+    def plot3; end
 
     # Draw one or more three-dimensional scatter plots.
-    def plot_scatter3; end
-    alias scatterplot3 plot_scatter3
+    def scatter3; end
 
     def redraw; end
 
@@ -172,35 +150,22 @@ module GR
     def imshow; end
 
     # Draw an isosurface.
-    def plot_isosurface; end
+    def isosurface; end
 
     # Draw one or more polar plots.
-    def plot_polar; end
+    def polar; end
 
     # Draw a triangular surface plot.
-    def plot_trisurf; end
+    def trisurf; end
 
     # Draw a triangular contour plot.
-    def plot_tricont; end
+    def tricont; end
 
-    def plot_shade; end
+    def shade; end
 
     # def set_panzoom ?
 
     # mainloop
-
-    # GR.plot do
-    #
-    # end
-    #
-    # GR.plot(:scatter, * * *)
-    def plot; end
-
-    # Object ?
-
-    # a = GR::Bar.new()
-    # a.draw ?
-    # a = GR::Bar.plot() ?
   end
 end
 

data/lib/gr_commons/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GRCommons
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-gr
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-01 00:00:00.000000000 Z
+date: 2019-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler