ruby-gr 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fd375d6fbd9ef427ca5eeb0540bf83b456ade3dac53e48572df7b4c2b5f2466
-  data.tar.gz: 127c524864be21dac6bf57c07f61546208b95559f359edff61d82048b7e16ff9
+  metadata.gz: a4952b2f2f30277b1fecfae2d49660addde63d4b1476aa63dacdba4643568294
+  data.tar.gz: a99aee8f75ff9f102ae713723e582aa9be12a1d1a5ef8fbede028df731d27ea3
 SHA512:
-  metadata.gz: 937b324d8199571ed75ac494889c6550bb35da07012f4770b23b37fe1b0aad0e853366c791bf1349fd96b531bf1292415925762271a8619e59aef6859ad7e6ab
-  data.tar.gz: 635b60aa7adc76b87bec35e11d419aaa402b49387b89b80534797b41f89ed8800fc3bb8e11321a6f4ea917ec2ff610c2e9c8b817ea13ed7091c78958bffdf078
+  metadata.gz: 0ba5e877d1363a6e27c986f5380ed169ea37615cb803633dea6fbb8e00a7d4c42bc7c52e9559e5d5719d094db6ed6b8cbe26d9a663cf94582545e9f0df715956
+  data.tar.gz: f2b76c28406593d64150e885a4f2d50731d3fb9d079677c94aaff7191a0a546d2bb23647352e729474ce9ebef619a12bac32b6d04045889a34cdbf0a44b21c6d

data/lib/gr.rb

@@ -25,6 +25,7 @@ module GR
              end
 
   require_relative 'gr_commons'
+  require_relative 'gr/version'
   require_relative 'gr/ffi'
   require_relative 'gr/grbase'
 
@@ -36,58 +37,118 @@ module GR
   # a FFI::MemoryPointer in the GRBase class.
 
   class << self
+    def initgr(*)
+      super
+    end
+
+    def opengks(*)
+      super
+    end
+
+    def closegks(*)
+      super
+    end
+
+    # inqdspsize
     def inqdspsize
       inquiry %i[double double int int] do |*pts|
         super(*pts)
       end
     end
 
+    def openws(*)
+      super
+    end
+
+    def closews(*)
+      super
+    end
+
+    def activatews(*)
+      super
+    end
+
+    def deactivatews(*)
+      super
+    end
+
+    def configurews(*)
+      super
+    end
+
+    def clearws(*)
+      super
+    end
+
+    def updatews(*)
+      super
+    end
+
+    # Draw a polyline using the current line attributes,
+    # starting from the first data point and ending at the last data point.
     def polyline(x, y)
       n = equal_length(x, y)
       super(n, x, y)
     end
 
+    # Draw marker symbols centered at the given data points.
     def polymarker(x, y)
       n = equal_length(x, y)
       super(n, x, y)
     end
 
+    def text(*)
+      super
+    end
+
+    # inqtext
     def inqtext(x, y, string)
       inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
         super(x, y, string, tbx, tby)
       end
     end
 
+    # Allows you to specify a polygonal shape of an area to be filled.
     def fillarea(x, y)
       n = equal_length(x, y)
       super(n, x, y)
     end
 
+    # Display rasterlike images in a device-independent manner.
+    # The cell array function partitions a rectangle given by two corner points into DIMX X DIMY cells,
+    # each of them colored individually by the corresponding color index of the given cell array.
     def cellarray(xmin, xmax, ymin, ymax, dimx, dimy, color)
       super(xmin, xmax, ymin, ymax, dimx, dimy, 1, 1, dimx, dimy, int(color))
     end
 
+    # Display a two dimensional color index array with nonuniform cell sizes.
     def nonuniformcellarray(x, y, dimx, dimy, color)
-      raise ArgumentError unless length(x) == dimx + 1 && length(y) == dimy + 1
+      raise ArgumentError unless x.length == dimx + 1 && y.length == dimy + 1
 
       super(x, y, dimx, dimy, 1, 1, dimx, dimy, int(color))
     end
 
+    # Display a two dimensional color index array mapped to a disk using polar coordinates.
     def polarcellarray(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, color)
       super(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, 1, 1, dimphi, dimr, int(color))
     end
 
+    # Generates a generalized drawing primitive (GDP) of the type you specify,
+    # using specified points and any additional information contained in a data record.
     def gdp(x, y, primid, datrec)
       n = equal_length(x, y)
-      ldr = length(datrec, :int)
+      ldr = datrec.length
       super(n, x, y, primid, ldr, datrec)
     end
 
+    # Generate a cubic spline-fit,
+    # starting from the first data point and ending at the last data point.
     def spline(px, py, m, method)
       n = equal_length(px, py)
       super(n, px, py, m, method)
     end
 
+    # gridit
     def gridit(xd, yd, zd, nx, ny)
       nd = equal_length(xd, yd, zd)
       inquiry [{ double: nx }, { double: ny }, { double: nx * ny }] do |px, py, pz|
@@ -95,169 +156,380 @@ module GR
       end
     end
 
+    def setlinetype(*)
+      super
+    end
+
+    # inqlinetype
     def inqlinetype
       inquiry_int { |pt| super(pt) }
     end
 
+    def setlinewidth(*)
+      super
+    end
+
+    # inqlinewidth
     def inqlinewidth
       inquiry_double { |pt| super(pt) }
     end
 
+    def setlinecolorind(*)
+      super
+    end
+
+    # inqlinecolorind
     def inqlinecolorind
       inquiry_int { |pt| super(pt) }
     end
 
+    def setmarkertype(*)
+      super
+    end
+
+    # inqmarkertype
     def inqmarkertype
       inquiry_int { |pt| super(pt) }
     end
 
+    def setmarkersize(*)
+      super
+    end
+
+    # inqmarkersize
+    def inqmarkersize
+      inquiry_double { |pt| super(pt) }
+    end
+
+    def setmarkercolorind(*)
+      super
+    end
+
+    # inqmarkercolorind
     def inqmarkercolorind
       inquiry_int { |pt| super(pt) }
     end
 
+    def settextfontprec(*)
+      super
+    end
+
+    def setcharexpan(*)
+      super
+    end
+
+    def setcharspace(*)
+      super
+    end
+
+    def settextcolorind(*)
+      super
+    end
+
+    def setcharheight(*)
+      super
+    end
+
+    def setcharup(*)
+      super
+    end
+
+    def settextpath(*)
+      super
+    end
+
+    def settextalign(*)
+      super
+    end
+
+    def setfillintstyle(*)
+      super
+    end
+
+    # inqfillintstyle
     def inqfillintstyle
       inquiry_int { |pt| super(pt) }
     end
 
+    def setfillstyle(*)
+      super
+    end
+
+    # inqfillstyle
     def inqfillstyle
       inquiry_int { |pt| super(pt) }
     end
 
+    def setfillcolorind(*)
+      super
+    end
+
+    # inqfillcolorind
     def inqfillcolorind
       inquiry_int { |pt| super(pt) }
     end
 
+    def setcolorrep(*)
+      super
+    end
+
+    def setscale(*)
+      super
+    end
+
+    # inqscale
     def inqscale
       inquiry_int { |pt| super(pt) }
     end
 
-    def inqtextext(x, y, string)
-      inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
-        super(x, y, string, tbx, tby)
-      end
+    def setwindow(*)
+      super
     end
 
+    # inqwindow
     def inqwindow
       inquiry %i[double double double double] do |*pts|
         super(*pts)
       end
     end
 
+    def setviewport(*)
+      super
+    end
+
+    # inqviewport
     def inqviewport
       inquiry %i[double double double double] do |*pts|
         super(*pts)
       end
     end
 
+    def selntran(*)
+      super
+    end
+
+    def setclip(*)
+      super
+    end
+
+    def setwswindow(*)
+      super
+    end
+
+    def setwsviewport(*)
+      super
+    end
+
+    def createseg(*)
+      super
+    end
+
+    def copysegws(*)
+      super
+    end
+
+    def redrawsegws(*)
+      super
+    end
+
+    def setsegtran(*)
+      super
+    end
+
+    def closeseg(*)
+      super
+    end
+
+    def emergencyclosegks(*)
+      super
+    end
+
+    def updategks(*)
+      super
+    end
+
+    def setspace(*)
+      super
+    end
+
+    # inqspace
     def inqspace
       inquiry %i[double double int int] do |*pts|
         super(*pts)
       end
     end
 
+    def textext(*)
+      super
+    end
+
+    # inqtextext
+    def inqtextext(x, y, string)
+      inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
+        super(x, y, string, tbx, tby)
+      end
+    end
+
+    def axes(*)
+      super
+    end
+
     alias axes2d axes
 
+    def grid(*)
+      super
+    end
+
+    def grid3d(*)
+      super
+    end
+
+    # Draw a standard vertical error bar graph.
     def verrorbars(px, py, e1, e2)
       n = equal_length(px, py, e1, e2)
       super(n, px, py, e1, e2)
     end
 
+    # Draw a standard horizontal error bar graph.
     def herrorbars(px, py, e1, e2)
       n = equal_length(px, py, e1, e2)
       super(n, px, py, e1, e2)
     end
 
+    # Draw a 3D curve using the current line attributes,
+    # starting from the first data point and ending at the last data point.
     def polyline3d(px, py, pz)
       n = equal_length(px, py, pz)
       super(n, px, py, pz)
     end
 
+    # Draw marker symbols centered at the given 3D data points.
     def polymarker3d(px, py, pz)
       n = equal_length(px, py, pz)
       super(n, px, py, pz)
     end
 
-    def surface(px, py, pz, option)
-      # TODO: check: Arrays have incorrect length or dimension.
-      nx = length(px)
-      ny = length(py)
-      super(nx, ny, px, py, pz, option)
+    def axes3d(*)
+      super
     end
 
-    def trisurface(px, py, pz)
-      n = [length(px), length(py), length(pz)].min
-      super(n, px, py, pz)
+    def titles3d(*)
+      super
     end
 
-    def gradient(x, y, z)
-      # TODO: check: Arrays have incorrect length or dimension.
-      nx = length(x)
-      ny = length(y)
-      inquiry [{ double: nx * ny }, { double: nx * ny }] do |pu, pv|
-        super(nx, ny, x, y, z, pu, pv)
-      end
-    end
-
-    def quiver(x, y, u, v, color)
+    # Draw a three-dimensional surface plot for the given data points.
+    def surface(px, py, pz, option)
       # TODO: check: Arrays have incorrect length or dimension.
-      nx = length(x)
-      ny = length(y)
-      super(nx, ny, x, y, u, v, (color ? 1 : 0))
+      nx = px.length
+      ny = py.length
+      super(nx, ny, px, py, pz, option)
     end
 
+    # Draw contours of a three-dimensional data set
+    # whose values are specified over a rectangular mesh.
+    # Contour lines may optionally be labeled.
     def contour(px, py, h, pz, major_h)
       # TODO: check: Arrays have incorrect length or dimension.
-      nx = length(px)
-      ny = length(py)
-      nh = h.size
+      nx = px.length
+      ny = py.length
+      nh = h.length
       super(nx, ny, nh, px, py, h, pz, major_h)
     end
 
+    # Draw filled contours of a three-dimensional data set
+    # whose values are specified over a rectangular mesh.
     def contourf(px, py, h, pz, major_h)
       # TODO: check: Arrays have incorrect length or dimension.
-      nx = length(px)
-      ny = length(py)
-      nh = h.size
+      nx = px.length
+      ny = py.length
+      nh = h.length
       super(nx, ny, nh, px, py, h, pz, major_h)
     end
 
+    # Draw a contour plot for the given triangle mesh.
     def tricontour(x, y, z, levels)
-      npoints = length(x) # equal_length ?
-      nlevels = length(levels)
+      npoints = x.length # equal_length ?
+      nlevels = levels.length
       super(npoints, x, y, z, nlevels, levels)
     end
 
+    # hexbin
     def hexbin(x, y, nbins)
-      n = length(x)
+      n = x.length
       super(n, x, y, nbins)
     end
 
+    def setcolormap(*)
+      super
+    end
+
+    # inqcolormap
     def inqcolormap
       inquiry_int { |pt| super(pt) }
     end
 
+    # Define a linear interpolated colormap by a list of RGB colors.
     def setcolormapfromrgb(r, g, b, positions: nil)
       n = equal_length(r, g, b)
       if positions.nil?
         positions = ::FFI::Pointer::NULL
       else
-        raise if length(positions) != n
+        raise if positions.length != n
       end
       super(n, r, g, b, positions)
     end
 
+    def colorbar(*)
+      super
+    end
+
+    # inqcolor
     def inqcolor(color)
       inquiry_int do |rgb|
         super(color, rgb)
       end
     end
 
+    def inqcolorfromrgb(*)
+      super
+    end
+
+    # hsvtorgb
     def hsvtorgb(h, s, v)
       inquiry %i[double double double] do |r, g, b|
         super(h, s, v, r, g, b)
       end
     end
 
+    def tick(*)
+      super
+    end
+
+    def validaterange(*)
+      super
+    end
+
+    def adjustlimits(*)
+      super
+    end
+
+    def adjustrange(*)
+      super
+    end
+
+    def beginprint(*)
+      super
+    end
+
+    def beginprintext(*)
+      super
+    end
+
+    def endprint(*)
+      super
+    end
+
+    # ndctowc
     def ndctowc(x, y)
       inquiry %i[double double] do |px, py|
         px.write_double x
@@ -266,6 +538,7 @@ module GR
       end
     end
 
+    # wctondc
     def wctondc(x, y)
       inquiry %i[double double] do |px, py|
         px.write_double x
@@ -274,6 +547,7 @@ module GR
       end
     end
 
+    # wc3towc
     def wc3towc(x, y, z)
       inquiry %i[double double double] do |px, py, pz|
         px.write_double x
@@ -283,43 +557,156 @@ module GR
       end
     end
 
+    def drawrect(*)
+      super
+    end
+
+    def fillrect(*)
+      super
+    end
+
+    def drawarc(*)
+      super
+    end
+
+    def fillarc(*)
+      super
+    end
+
+    # Draw simple and compound outlines consisting of line segments and bezier curves.
     def drawpath(points, codes, fill)
-      len = length(codes)
+      len = codes.length
       super(len, points, uint8(codes), fill)
     end
 
+    def setarrowstyle(*)
+      super
+    end
+
+    def setarrowsize(*)
+      super
+    end
+
+    def drawarrow(*)
+      super
+    end
+
+    # readimage
+    def readimage(path)
+      w, h, d = inquiry [:int, :int, :pointer] do |width, height, data|
+        # data is a pointer of a pointer
+        super(path, width, height, data)
+      end
+      [w, h, d.read_array_of_uint(w * h)]
+    end
+
+    # Draw an image into a given rectangular area.
     def drawimage(xmin, xmax, ymin, ymax, width, height, data, model = 0)
-      super(xmin, xmax, ymin, ymax, width, height, int(data), model)
+      super(xmin, xmax, ymin, ymax, width, height, uint(data), model)
+    end
+
+    def importgraphics(*)
+      super
     end
 
+    def setshadow(*)
+      super
+    end
+
+    def settransparency(*)
+      super
+    end
+
+    # Change the coordinate transformation according to the given matrix.
     def setcoordxform(mat)
       raise if mat.size != 6
 
       super(mat)
     end
 
+    def begingraphics(*)
+      super
+    end
+
+    def endgraphics(*)
+      super
+    end
+
+    def getgraphics(*)
+      super
+    end
+
+    def drawgraphics(*)
+      super
+    end
+
+    def mathtex(*)
+      super
+    end
+
+    # inqmathtex
     def inqmathtex(x, y, string)
       inquiry [{ double: 4 }, { double: 4 }] do |tbx, tby|
         super(x, y, string, tbx, tby)
       end
     end
 
+    def beginselection(*)
+      super
+    end
+
+    def endselection(*)
+      super
+    end
+
+    def moveselection(*)
+      super
+    end
+
+    def resizeselection(*)
+      super
+    end
+
+    # inqbbox
     def inqbbox
       inquiry %i[double double double double] do |*pts|
         super(*pts)
       end
     end
 
-    def adjustlimits(_amin, _amax)
-      inquiry %i[double double] do |*pts|
-        super(*pts)
-      end
+    def precision(*)
+      super
     end
 
-    def version
-      super.read_string
+    def setregenflags(*)
+      super
+    end
+
+    def inqregenflags(*)
+      super
+    end
+
+    def savestate(*)
+      super
+    end
+
+    def restorestate(*)
+      super
+    end
+
+    def selectcontext(*)
+      super
+    end
+
+    def destroycontext(*)
+      super
+    end
+
+    def uselinespec(*)
+      super
     end
 
+    # Reduces the number of points of the x and y array.
     def reducepoints(xd, yd, n)
       nd = equal_length(xd, yd)
       inquiry [{ double: n }, { double: n }] do |x, y|
@@ -328,18 +715,66 @@ module GR
       end
     end
 
+    # Draw a triangular surface plot for the given data points.
+    def trisurface(px, py, pz)
+      n = [px, py, pz].map(&:length).min
+      super(n, px, py, pz)
+    end
+
+    # gradient
+    def gradient(x, y, z)
+      # TODO: check: Arrays have incorrect length or dimension.
+      nx = x.length
+      ny = y.length
+      inquiry [{ double: nx * ny }, { double: nx * ny }] do |pu, pv|
+        super(nx, ny, x, y, z, pu, pv)
+      end
+    end
+
+    # quiver
+    def quiver(x, y, u, v, color)
+      # TODO: check: Arrays have incorrect length or dimension.
+      nx = x.length
+      ny = y.length
+      super(nx, ny, x, y, u, v, (color ? 1 : 0))
+    end
+
+    # interp2
+    def interp2(x, y, z, xq, yq, method, extrapval) # flatten
+      nx = x.length
+      ny = y.length
+      # nz = z.length
+      nxq = xq.length
+      nyq = yq.length
+      inquiry(double: nxq * nyq) do |zq|
+        super(nx, ny, x, y, z, nxq, nyq, xq, yq, zq, method, extrapval)
+      end
+    end
+
+    # version
+    def version
+      super.read_string
+    end
+
+    # Display a point set as a aggregated and rasterized image.
     def shadepoints(x, y, dims: [1200, 1200], xform: 1)
-      n = length(x)
+      n = x.length
       w, h = dims
       super(n, x, y, xform, w, h)
     end
 
+    # Display a line set as an aggregated and rasterized image.
     def shadelines(x, y, dims: [1200, 1200], xform: 1)
-      n = length(x)
+      n = x.length
       w, h = dims
       super(n, x, y, xform, w, h)
     end
 
+    def panzoom(*)
+      super
+    end
+
+    # panzoom
     def panzoom(x, y, zoom)
       inquiry %i[double double double double] do |xmin, xmax, ymin, ymax|
         super(x, y, zoom, zoom, xmin, xmax, ymin, ymax)