plplot 0.0.0

data/examples/x21.rb

@@ -0,0 +1,280 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+include PLplot::PL
+include Math
+
+# Grid data demo
+#
+# Copyright (C) 2004  Joao Cardoso
+#
+# This file is part of PLplot.
+#
+# PLplot is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Library Public License as published
+# by the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# PLplot is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Library General Public License for more details.
+#
+# You should have received a copy of the GNU Library General Public License
+# along with PLplot; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+# Options data structure definition
+
+# Defaults for user options.  Use global variables to track user options since
+# that matches the C example most closely.
+
+$pts       = 500
+$xp        = 25
+$yp        = 20
+$nl        = 16
+$knn_order = 20
+$threshold = 1.001
+$wmin      = -1e3 # No option for this?
+$randn     = false
+$rosen     = false
+
+PLOP = PLOptionParser.new do |op|
+  op.separator('')
+  op.separator('x21 options:')
+  op.on('--npts NPOINTS', Integer, 'Specify number of random points',
+        "to generate [#{$pts}]") do |o|
+    $npts = o
+  end
+  op.on('--randn', 'Normal instead of uniform sampling',
+        'the effective number of points will be',
+        'smaller than the specified number') do
+    $randn = true
+  end
+  op.on('--rosen', 'Generate using the Rosenbrock function.') do
+    $rosen = true
+  end
+  op.on('--nx NXPOINTS', Integer, "Specify grid x dimension [#{$xp}]") do |o|
+    $xp = o
+  end
+  op.on('--ny NYPOINTS', Integer, "Specify grid y dimension [#{$yp}]") do |o|
+    $yp = o
+  end
+  op.on('--nlevel NLEVELS', Integer, "Specify number of contour levels [#{$nl}]") do |o|
+    $nl = o
+  end
+  op.on('--knn_order ORDER', Integer, "Specify the number of neighbors [#{$knn_order}]") do |o|
+    $knn_order = o
+  end
+  op.on('--threshold FLOAT', Float, "Specify what a thin triangle is", "[1 < [#{$threshold}] < 2]") do |o|
+    $threshold = o
+  end
+end
+
+# Makes transliteration from C example easier
+def pow(a,b)
+  a ** b
+end
+
+def cmap1_init
+    i = [ 0.0, 1.0 ]   # left, right boundary
+
+    h = [ 240, 0 ]     # blue -> green -> yellow -> red
+
+    l = [ 0.6, 0.6 ]
+
+    s = [ 0.8, 0.8 ]
+
+    plscmap1n(256)
+    plscmap1l(0, i, h, l, s)
+end
+
+def create_grid(px, py)
+    x = NArray.float(px)
+    y = NArray.float(py)
+
+    px.times do |i|
+        x[i] = XMIN + (XMAX - XMIN) * i / (px - 1.0)
+    end
+
+    py.times do |i|
+        y[i] = YMIN + (YMAX - YMIN) * i / (py - 1.0)
+    end
+
+    [x, y]
+end
+
+def create_data(pts, randn, rosen)
+    x = NArray.float(pts)
+    y = NArray.float(pts)
+    z = NArray.float(pts)
+
+    pts.times do |i|
+        xt = (XMAX - XMIN) * plrandd
+        yt = (YMAX - YMIN) * plrandd
+        if !randn
+            x[i] = xt + XMIN
+            y[i] = yt + YMIN
+        else # std=1, meaning that many points are outside the plot range
+            x[i] = sqrt(-2 * log(xt)) * cos(2 * PI * yt) + XMIN
+            y[i] = sqrt(-2 * log(xt)) * sin(2 * PI * yt) + YMIN
+        end
+        if (!rosen)
+            r  = sqrt(x[i] * x[i] + y[i] * y[i])
+            z[i] = exp(-r * r) * cos(2 * PI * r)
+        else
+            z[i] = log(pow(1 - x[i], 2) + 100 * pow(y[i] - pow(x[i], 2), 2))
+        end
+    end
+
+    [x, y, z]
+end
+
+title = [
+  "Cubic Spline Approximation",
+  "Delaunay Linear Interpolation",
+  "Natural Neighbors Interpolation",
+  "KNN Inv. Distance Weighted",
+  "3NN Linear Interpolation",
+  "4NN Around Inv. Dist. Weighted"
+]
+
+opt = [ 0, 0, 0, 0, 0, 0 ]
+
+XMIN = YMIN = -0.2
+XMAX = YMAX =  0.6
+
+PLOP.parse!
+
+opt[2] = $wmin
+opt[3] = $knn_order
+opt[4] = $threshold
+
+# Initialize plplot
+
+plinit
+
+# Initialise random number generator
+plseed(5489)
+
+x, y, z = create_data($pts, $randn, $rosen); # the sampled data
+zmin, zmax = plMinMax2dGrid(z)
+
+xg, yg = create_grid($xp, $yp) # grid the data at
+zg = NArray.float($yp, $xp)    # the output grided data
+clev = NArray.float($nl)
+
+# printf("Npts=%d gridx=%d gridy=%d", $pts, $xp, $yp)
+plcol0(1)
+plenv(XMIN, XMAX, YMIN, YMAX, 2, 0)
+plcol0(15)
+pllab("X", "Y", "The original data sampling")
+plcol0(2)
+plpoin(x, y, 5)
+pladv(0)
+
+plssub(3, 2)
+
+2.times do |k|
+  pladv(0)
+  (1...7).each do |alg|
+    plgriddata(x, y, z, zg, alg, opt[alg - 1], xg, yg)
+
+    # - CSA can generate NaNs (only interpolates?!).
+    # - DTLI and NNI can generate NaNs for points outside the convex hull
+    #      of the data points.
+    # - NNLI can generate NaNs if a sufficiently thick triangle is not found
+    #
+    # PLplot should be NaN/Inf aware, but changing it now is quite a job...
+    # so, instead of not plotting the NaN regions, a weighted average over
+    # the neighbors is done.
+
+    if (alg == GRID_CSA || alg == GRID_DTLI || alg == GRID_NNLI || alg == GRID_NNI)
+      $xp.times do |i|
+        $yp.times do |j|
+          if zg[j,i].nan? # average (IDW) over the 8 neighbors
+
+            zg[j,i] = 0.0; dist = 0.0
+
+            (i-1..i+1).each do |ii|
+              next unless (0...$xp) === ii
+
+              (j-1..j+1).each do |jj|
+                next unless (0...$yp) === jj
+
+                if !zg[jj,ii].nan?
+                  d        = (ii - i).abs + (jj - j).abs == 1 ? 1.0 : 1.4142
+                  zg[j,i] += zg[jj,ii] / (d * d)
+                  dist    += d
+                end
+              end
+            end
+            if (dist != 0.0)
+              zg[j,i] /= dist
+            else
+              zg[j,i] = zmin
+            end
+          end
+        end
+      end
+    end
+
+    lzmin, lzmax = plMinMax2dGrid(zg)
+
+    lzmin =  zmin if zmin < lzmin
+    lzmax =  zmax if zmax > lzmax
+
+    # Increase limits slightly to prevent spurious contours
+    # due to rounding errors
+    lzmin = lzmin - 0.01
+    lzmax = lzmax + 0.01
+
+    plcol0(1)
+
+    pladv(alg)
+
+    if k == 0
+      $nl.times do |i|
+        clev[i] = lzmin + (lzmax - lzmin) / ($nl - 1) * i
+      end
+
+      plenv0(XMIN, XMAX, YMIN, YMAX, 2, 0)
+      plcol0(15)
+      pllab("X", "Y", title[alg - 1])
+      plshade(zg, XMIN..XMAX, YMIN..YMAX, clev,
+              1, # fill_width
+              0, # cont_color
+              1, # cont_width
+              1  # rectangular?
+             )
+      plcol0(2)
+    else
+      $nl.times do |i|
+        clev[i] = lzmin + (lzmax - lzmin) / ($nl - 1) * i
+      end
+
+      cmap1_init
+      plvpor(0.0, 1.0, 0.0, 0.9)
+      plwind(-1.1, 0.75, -0.65, 1.20)
+
+      # For the comparison to be fair, all plots should have the
+      # same z values, but to get the max/min of the data generated
+      # by all algorithms would imply two passes. Keep it simple.
+      #
+      # plw3d(1, 1, 1, XMIN, XMAX, YMIN, YMAX, zmin, zmax, 30, -60)
+
+      plw3d(1, 1, 1, XMIN, XMAX, YMIN, YMAX, lzmin, lzmax, 30, -40)
+      plbox3("bntu", "X", 0, 0,
+             "bntu", "Y", 0.0, 0,
+             "bcdfntu", "Z", 0.5, 0)
+      plcol0(15)
+      pllab("", "", title[alg - 1])
+      plot3dc(xg, yg, zg, DRAW_LINEXY | MAG_COLOR | BASE_CONT, clev)
+    end
+  end
+end
+
+plend

data/examples/x22.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+include Math
+
+#  Simple vector plot example
+#  Copyright (C) 2004 Andrew Ross <andrewross@users.sourceforge.net>
+#  Copyright (C) 2004  Rafael Laboissiere
+#
+#
+#  This file is part of PLplot.
+#
+#  PLplot is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Library Public License as published
+#  by the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  PLplot is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Library General Public License for more details.
+#
+#  You should have received a copy of the GNU Library General Public License
+#  along with PLplot; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+# Makes transliteration from C example easier
+def pow(a,b)
+  a ** b
+end
+
+#  Pairs of points making the line segments used to plot the user defined arrow 
+ARROW_X  = [ -0.5, 0.5, 0.3, 0.5,  0.3, 0.5 ]
+ARROW_Y  = [  0.0, 0.0, 0.2, 0.0, -0.2, 0.0 ]
+ARROW2_X = [ -0.5, 0.3, 0.3, 0.5,  0.3, 0.3 ]
+ARROW2_Y = [  0.0, 0.0, 0.2, 0.0, -0.2, 0.0 ]
+
+# Generates several simple vector plots.
+
+# Vector plot of the circulation about the origin
+def circulation
+  nx = 20
+  ny = 20
+
+  dx = 1.0
+  dy = 1.0
+
+  xmin = -nx / 2 * dx
+  xmax =  nx / 2 * dx
+  ymin = -ny / 2 * dy
+  ymax =  ny / 2 * dy
+
+  xg = NArray.float(ny, nx)
+  yg = NArray.float(ny, nx)
+  u = NArray.float(ny, nx)
+  v = NArray.float(ny, nx)
+
+  #  Create data - circulation around the origin. 
+  nx.times do |i|
+    x = (i - nx / 2 + 0.5) * dx
+    ny.times do |j|
+      y = (j - ny / 2 + 0.5) * dy
+      xg[j,i] = x
+      yg[j,i] = y
+      u[j,i]  = y
+      v[j,i]  = -x
+    end
+  end
+
+  #  Plot vectors with default arrows 
+  plenv(xmin, xmax, ymin, ymax, 0, 0)
+  pllab("(x)", "(y)", "#frPLplot Example 22 - circulation")
+  plcol0(2)
+  plvect(u, v, xg, yg)
+  plcol0(1)
+end
+
+# Vector plot of flow through a constricted pipe
+def constriction
+  nx = 20
+  ny = 20
+
+  dx = 1.0
+  dy = 1.0
+
+  xmin = -nx / 2 * dx
+  xmax =  nx / 2 * dx
+  ymin = -ny / 2 * dy
+  ymax =  ny / 2 * dy
+
+  xg = NArray.float(ny, nx)
+  yg = NArray.float(ny, nx)
+  u = NArray.float(ny, nx)
+  v = NArray.float(ny, nx)
+
+  q = 2.0
+  nx.times do |i|
+    x = (i - nx / 2 + 0.5) * dx
+    ny.times do |j|
+      y = (j - ny / 2 + 0.5) * dy
+      xg[j,i] = x
+      yg[j,i] = y
+      b = ymax / 4.0 * (3 - cos(PI * x / xmax))
+      if (y.abs < b)
+        dbdx = ymax / 4.0 * sin(PI * x / xmax) * y / b
+        u[j,i] = q * ymax / b
+        v[j,i] = dbdx * u[j,i]
+      else
+        u[j,i] = 0.0
+        v[j,i] = 0.0
+      end
+    end
+  end
+
+  plenv(xmin, xmax, ymin, ymax, 0, 0)
+  pllab("(x)", "(y)", "#frPLplot Example 22 - constriction")
+  plcol0(2)
+  plvect(u, v, xg, yg, -0.5)
+  plcol0(1)
+end
+
+
+# Vector plot of the gradient of a shielded potential (see example 9)
+def potential
+  nper   = 100
+  nlevel = 10
+  nr     = 20
+  ntheta = 20
+
+  px = NArray.float(nper)
+  py = NArray.float(nper)
+  clevel = NArray.float(nlevel)
+
+  #  Create data to be plotted 
+  xg = NArray.float(ntheta, nr)
+  yg = NArray.float(ntheta, nr)
+  u  = NArray.float(ntheta, nr)
+  v  = NArray.float(ntheta, nr)
+  z  = NArray.float(ntheta, nr)
+
+  # Potential inside a conducting cylinder (or sphere) by method of images.
+  # Charge 1 is placed at (d1, d1), with image charge at (d2, d2).
+  # Charge 2 is placed at (d1, -d1), with image charge at (d2, -d2).
+  # Also put in smoothing term at small distances.
+
+  rmax = nr.to_f
+
+  eps = 2.0
+
+  q1 = 1.0
+  d1 = rmax / 4.0
+
+  q1i = -q1 * rmax / d1
+  d1i = pow(rmax, 2.0) / d1
+
+  q2 = -1.0
+  d2 = rmax / 4.0
+
+  q2i = -q2 * rmax / d2
+  d2i = pow(rmax, 2.0) / d2
+
+  nr.times do |i|
+    r = 0.5 + i
+    ntheta.times do |j|
+      theta   = 2.0 * PI / (ntheta - 1) * (0.5 + j)
+      x       = r * cos(theta)
+      y       = r * sin(theta)
+      xg[j,i] = x
+      yg[j,i] = y
+      div1    = sqrt(pow(x - d1, 2.0) + pow(y - d1, 2.0) + pow(eps, 2.0))
+      div1i   = sqrt(pow(x - d1i, 2.0) + pow(y - d1i, 2.0) + pow(eps, 2.0))
+      div2    = sqrt(pow(x - d2, 2.0) + pow(y + d2, 2.0) + pow(eps, 2.0))
+      div2i   = sqrt(pow(x - d2i, 2.0) + pow(y + d2i, 2.0) + pow(eps, 2.0))
+      z[j,i]  = q1 / div1 + q1i / div1i + q2 / div2 + q2i / div2i
+      u[j,i]  = -q1 * (x - d1) / pow(div1, 3.0) - q1i * (x - d1i) / pow(div1i, 3.0) \
+                - q2 * (x - d2) / pow(div2, 3.0) - q2i * (x - d2i) / pow(div2i, 3.0)
+      v[j,i]  = -q1 * (y - d1) / pow(div1, 3.0) - q1i * (y - d1i) / pow(div1i, 3.0) \
+                - q2 * (y + d2) / pow(div2, 3.0) - q2i * (y + d2i) / pow(div2i, 3.0)
+    end
+  end
+
+  xmin, xmax = plMinMax2dGrid(xg)
+  ymin, ymax = plMinMax2dGrid(yg)
+  zmin, zmax = plMinMax2dGrid( z)
+
+  plenv(xmin, xmax, ymin, ymax, 0, 0)
+  pllab("(x)", "(y)", "#frPLplot Example 22 - potential gradient vector plot")
+  #  Plot contours of the potential 
+  dz = (zmax - zmin) / nlevel
+  nlevel.times do |i|
+    clevel[i] = zmin + (i + 0.5) * dz
+  end
+  plcol0(3)
+  pllsty(2)
+  plcont(z, nil, nil, clevel, xg, yg)
+  pllsty(1)
+  plcol0(1)
+
+  #  Plot the vectors of the gradient of the potential 
+  plcol0(2)
+  plvect(u, v, xg, yg, 25.0)
+  plcol0(1)
+
+  #  Plot the perimeter of the cylinder 
+  nper.times do |i|
+    theta = (2.0 * PI / (nper - 1)) * i
+    px[i] = rmax * cos(theta)
+    py[i] = rmax * sin(theta)
+  end
+  plline(px, py)
+
+end
+
+# Parse and process command line arguments
+
+PLOptionParser.parse!
+
+#  Initialize plplot 
+
+plinit
+
+circulation
+
+fill = 0
+
+# Set arrow style using ARROW_X and ARROW_Y then
+# plot using these arrows.
+plsvect(ARROW_X, ARROW_Y, fill)
+constriction
+
+# Set arrow style using ARROW2_X and ARROW2_Y then
+# plot using these filled arrows. */
+fill = 1
+plsvect(ARROW2_X, ARROW2_Y, fill)
+constriction
+
+potential
+
+plend