plplot 0.0.0

data/examples/x09.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+include Math
+
+# Contour plot demo.
+#
+# 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
+
+
+XPTS = 35  # Data points in x
+YPTS = 46  # Data points in y
+
+XSPA = 2.0/(XPTS-1)
+YSPA = 2.0/(YPTS-1)
+
+# polar plot data
+PERIMETERPTS  = 100
+RPTS = 40
+THETAPTS = 40
+
+# potential plot data
+PPERIMETERPTS = 100
+PRPTS = 40
+PTHETAPTS = 64
+PNLEVEL = 20
+
+CLEVEL = [-1.0, -0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
+
+# Makes transliteration from C example easier
+def pow(a,b)
+  a ** b
+end
+
+# Transformation function
+
+TR = [XSPA, 0.0, -1.0, 0.0, YSPA, -1.0]
+
+def mypltr(x, y, tr)
+  tx = tr[0] * x.to_f + tr[1] * y.to_f + tr[2];
+  ty = tr[3] * x.to_f + tr[4] * y.to_f + tr[5];
+  [tx, ty]
+end
+
+# polar contour plot example.
+def polar
+
+  plenv(-1.0, 1.0, -1.0, 1.0, 0, -2);
+  plcol0(1);
+
+  # Perimeter
+  px = []
+  py = []
+  PERIMETERPTS.times do |i|
+    t = (2.0*PI/(PERIMETERPTS-1.0))*i;
+    px[i] = cos(t);
+    py[i] = sin(t);
+  end
+  plline(px, py);
+
+  # create data to be contoured.
+  xg = NArray.float(THETAPTS, RPTS);
+  yg = NArray.float(THETAPTS, RPTS);
+  z  = NArray.float(THETAPTS, RPTS);
+  nx = RPTS;
+  ny = THETAPTS;
+
+  RPTS.times do |i|
+    r = i.to_f/(RPTS-1);
+    THETAPTS.times do |j|
+      theta = (2.0*PI/(THETAPTS-1.0))*j;
+      xg[j,i] = r*cos(theta);
+      yg[j,i] = r*sin(theta);
+      z[j,i] = r;
+    end
+  end
+
+  lev = [];
+  10.times do |i|
+    lev[i] = 0.05 + 0.10 * i;
+  end
+
+  plcol0(2);
+  plcont(z, nil, nil, lev, xg, yg)
+  plcol0(1);
+  pllab("", "", "Polar Contour Plot");
+end
+
+# shielded potential contour plot example.
+def potential()
+  # create data to be contoured.
+  xg = NArray.float(PTHETAPTS, PRPTS);
+  yg = NArray.float(PTHETAPTS, PRPTS);
+  z  = NArray.float(PTHETAPTS, PRPTS);
+  nx = PRPTS;
+  ny = PTHETAPTS;
+
+  PRPTS.times do |i|
+    r = 0.5 + i;
+    PTHETAPTS.times do |j|
+      theta = (2.0*PI/(PTHETAPTS-1.0))*(0.5 + j);
+      xg[j,i] = r*cos(theta);
+      yg[j,i] = r*sin(theta);
+    end
+  end
+
+  rmax = PRPTS;
+  xmin, xmax = plMinMax2dGrid(xg);
+  ymin, ymax = plMinMax2dGrid(yg);
+  x0 = (xmin + xmax)/2.0;
+  y0 = (ymin + ymax)/2.0;
+
+  # Expanded limits
+  peps = 0.05;
+  xpmin = xmin - xmin.abs*peps;
+  xpmax = xmax + xmax.abs*peps;
+  ypmin = ymin - ymin.abs*peps;
+  ypmax = ymax + ymax.abs*peps;
+
+  # 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.
+
+  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;
+
+  PRPTS.times do |i|
+    PTHETAPTS.times do |j|
+      div1  = sqrt(pow(xg[j,i]-d1,  2.0) + pow(yg[j,i]-d1,  2.0) + pow(eps, 2.0));
+      div1i = sqrt(pow(xg[j,i]-d1i, 2.0) + pow(yg[j,i]-d1i, 2.0) + pow(eps, 2.0));
+      div2  = sqrt(pow(xg[j,i]-d2,  2.0) + pow(yg[j,i]+d2,  2.0) + pow(eps, 2.0));
+      div2i = sqrt(pow(xg[j,i]-d2i, 2.0) + pow(yg[j,i]+d2i, 2.0) + pow(eps, 2.0));
+      z[j,i] = q1/div1 + q1i/div1i + q2/div2 + q2i/div2i;
+    end
+  end
+  zmin, zmax = plMinMax2dGrid(z);
+=begin
+  printf("%.15g %.15g %.15g %.15g %.15g %.15g %.15g %.15g \n",
+          q1, d1, q1i, d1i, q2, d2, q2i, d2i);
+   printf("%.15g %.15g %.15g %.15g %.15g %.15g \n",
+          xmin, xmax, ymin, ymax, zmin, zmax);
+=end
+
+  # Positive and negative contour levels.
+  dz = (zmax-zmin)/PNLEVEL;
+  nlevelneg = 0;
+  nlevelpos = 0;
+  clevelneg = []
+  clevelpos = []
+  PNLEVEL.times do |i|
+    clevel = zmin + (i + 0.5)*dz;
+    if (clevel <= 0.0)
+      clevelneg[nlevelneg] = clevel;
+      nlevelneg += 1
+    else
+      clevelpos[nlevelpos] = clevel;
+      nlevelpos += 1
+    end
+  end
+  # Colours!
+  ncollin = 11;
+  ncolbox = 1;
+  ncollab = 2;
+
+  # Finally start plotting this page!
+  pladv(0);
+  plcol0(ncolbox);
+
+  plvpas(0.1, 0.9, 0.1, 0.9, 1.0);
+  plwind(xpmin, xpmax, ypmin, ypmax);
+  plbox("", 0.0, 0, "", 0.0, 0);
+
+  plcol0(ncollin);
+  if(nlevelneg > 0)
+    # Negative contours
+    pllsty(2);
+    plcont(z, nil, nil, clevelneg, xg, yg);
+  end
+
+  if(nlevelpos >0)
+    # Positive contours
+    pllsty(1);
+    plcont(z, nil, nil, clevelpos, xg, yg);
+  end
+
+  # Draw outer boundary
+  px = NArray.float(PPERIMETERPTS)
+  py = NArray.float(PPERIMETERPTS)
+  PPERIMETERPTS.times do |i|
+    t = (2.0*PI/(PPERIMETERPTS-1.0))*i;
+    px[i] = x0 + rmax*cos(t);
+    py[i] = y0 + rmax*sin(t);
+  end
+
+  plcol0(ncolbox);
+  plline(px, py);
+
+  plcol0(ncollab);
+  pllab("", "", "Shielded potential of charges in a conducting sphere");
+end
+
+
+#--------------------------------------------------------------------------
+# Does several contour plots using different coordinate mappings.
+#--------------------------------------------------------------------------
+
+mark  = 1500
+space = 1500
+
+# Parse and process command line arguments
+
+PLOptionParser.parse!
+
+# Initialize plplot
+
+plinit();
+
+# Set up function arrays
+
+xg1 = NArray.float(XPTS)
+yg1 = NArray.float(YPTS);
+z = NArray.float(YPTS, XPTS);
+w = NArray.float(YPTS, XPTS);
+
+XPTS.times do |i|
+  xx = (i - (XPTS / 2.0)) / (XPTS / 2.0);
+  YPTS.times do |j|
+    yy = (j - (YPTS / 2.0)) / (YPTS / 2.0) - 1.0;
+    z[j,i] = xx * xx - yy * yy;
+    w[j,i] = 2 * xx * yy;
+  end
+end
+
+# Set up grids
+
+xg = NArray.float(YPTS, XPTS)
+yg = NArray.float(YPTS, XPTS);
+
+XPTS.times do |i|
+  YPTS.times do |j|
+    xx, yy = mypltr(i, j, TR);
+
+    argx = xx * PI/2;
+    argy = yy * PI/2;
+    distort = 0.4;
+
+    xg1[i] = xx + distort * cos(argx);
+    yg1[j] = yy - distort * cos(argy);
+
+    xg[j,i] = xx + distort * cos(argx) * cos(argy);
+    yg[j,i] = yy - distort * cos(argx) * cos(argy);
+  end
+end
+
+# Plot using identity transform
+=begin
+    plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+    plcol0(2);
+    plcont(z, nil, nil, CLEVEL) {|x,y| mypltr(x,y,TR)}
+    plstyl(mark, space);
+    plcol0(3);
+    plcont(w, nil, nil, CLEVEL) {|x,y| mypltr(x,y,TR)}
+    plstyl
+    plcol0(1);
+    pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+=end
+pl_setcontlabelformat(4,3);
+pl_setcontlabelparam(0.006, 0.3, 0.1, 1);
+plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+plcol0(2);
+plcont(z, nil, nil, CLEVEL) {|x,y| mypltr(x,y,TR)}
+plstyl(mark, space);
+plcol0(3);
+plcont(w, nil, nil, CLEVEL) {|x,y| mypltr(x,y,TR)}
+plstyl
+plcol0(1);
+pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+pl_setcontlabelparam(0.006, 0.3, 0.1, 0);
+
+# Plot using 1d coordinate transform
+
+plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+plcol0(2);
+plcont(z, nil, nil, CLEVEL, xg1, yg1)
+
+plstyl(mark, space);
+plcol0(3);
+plcont(w, nil, nil, CLEVEL, xg1, yg1)
+plstyl
+plcol0(1);
+pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+=begin
+    pl_setcontlabelparam(0.006, 0.3, 0.1, 1);
+    plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+    plcol0(2);
+    plcont(z, nil, nil, CLEVEL, xg1, yg1)
+
+    plstyl(mark, space);
+    plcol0(3);
+    plcont(z, nil, nil, CLEVEL, xg1, yg1)
+    plstyl
+    plcol0(1);
+    pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+    pl_setcontlabelparam(0.006, 0.3, 0.1, 0);
+=end
+
+# Plot using 2d coordinate transform
+
+plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+plcol0(2);
+plcont(z, nil, nil, CLEVEL, xg, yg)
+
+plstyl(mark, space);
+plcol0(3);
+plcont(w, nil, nil, CLEVEL, xg, yg)
+plstyl
+plcol0(1);
+pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+=begin
+    pl_setcontlabelparam(0.006, 0.3, 0.1, 1);
+    plenv(-1.0, 1.0, -1.0, 1.0, 0, 0);
+    plcol0(2);
+    plcont(z, nil, nil, CLEVEL, xg, yg)
+
+    plstyl(mark, space);
+    plcol0(3);
+    plcont(w, nil, nil, CLEVEL, xg, yg)
+    plstyl(
+    plcol0(1);
+    pllab("X Coordinate", "Y Coordinate", "Streamlines of flow");
+=end
+pl_setcontlabelparam(0.006, 0.3, 0.1, 0);
+#pl_setcontlabelparam(0.006, 0.3, 0.1, 1);
+polar();
+
+pl_setcontlabelparam(0.006, 0.3, 0.1, 0);
+#pl_setcontlabelparam(0.006, 0.3, 0.1, 1);
+potential();
+
+# Clean up
+
+plend();

data/examples/x10.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+
+# Window positioning demo.
+#
+# Demonstrates absolute positioning of graphs on a page.
+
+# Parse and process command line arguments
+
+PLOptionParser.parse!
+
+# Initialize plplot
+
+plinit
+
+pladv(0)
+plvpor(0.0, 1.0, 0.0, 1.0)
+plwind(0.0, 1.0, 0.0, 1.0)
+plbox("bc", 0.0, 0, "bc", 0.0, 0)
+
+plsvpa(50.0, 150.0, 50.0, 100.0)
+plwind(0.0, 1.0, 0.0, 1.0)
+plbox("bc", 0.0, 0, "bc", 0.0, 0)
+plptex(0.5, 0.5, 1.0, 0.0, 0.5, "BOX at (50,150,50,100)")
+plend

data/examples/x11.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+include Math
+
+# Mesh plot demo.
+#
+# 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
+
+XPTS   = 35            # Data points in x
+YPTS   = 46            # Data points in y
+LEVELS = 10
+
+opt = [ PL::DRAW_LINEXY, PL::DRAW_LINEXY ]
+
+alt = [ 33.0,  17.0 ]
+az  = [ 24.0, 115.0 ]
+
+title = [
+    "#frPLplot Example 11 - Alt=33, Az=24, Opt=3",
+    "#frPLplot Example 11 - Alt=17, Az=115, Opt=3",
+]
+
+# Makes transliteration from C example easier
+def pow(a,b)
+  a ** b
+end
+
+def cmap1_init()
+
+  i = [0.0, 1.0]     # left, right boundaries
+
+  h = [240, 0]       # blue -> green -> yellow -> red
+  l = [0.6, 0.6]
+  s = [0.8, 0.8]
+
+  plscmap1n( 256 )
+  plscmap1l(PL::CMAP_HLS, i, h, l, s)
+end
+
+#--------------------------------------------------------------------------
+# Does a series of mesh plots for a given data set, with different
+# viewing options in each plot.
+#--------------------------------------------------------------------------
+
+# Parse and process command line arguments
+
+PLOptionParser.parse!
+
+# Initialize plplot
+
+plinit
+
+# Could be done more tersely using NArray methods, but this is a closer
+# transliteration from the C example.
+
+x = NArray.float(XPTS)
+y = NArray.float(YPTS)
+
+z = NArray.float(YPTS, XPTS)
+
+XPTS.times do |i|
+  x[i] = 3.0 * ( i - ( XPTS / 2.0 ) ) / ( XPTS / 2.0 )
+end
+
+YPTS.times do |i|
+  y[i] = 3.0 * ( i - ( YPTS / 2.0 ) ) / ( YPTS / 2.0 )
+end
+
+XPTS.times do |i|
+  xx = x[i]
+  YPTS.times do |j|
+    yy      = y[j]
+    z[j,i] = 3.0 * ( 1.0 - xx ) * ( 1.0 - xx ) * exp( -( xx * xx ) - ( yy + 1.0 ) * ( yy + 1.0 ) ) -
+      10.0 * ( xx / 5.0 - pow( xx, 3.0 ) - pow( yy, 5.0 ) ) * exp( -xx * xx - yy * yy ) -
+      1.0 / 3.0 * exp( -( xx + 1 ) * ( xx + 1 ) - ( yy * yy ) )
+
+    if ( false ) # Jungfraujoch/Interlaken
+      if ( z[j,i] < -1.0 )
+        z[j,i] = -1.0
+      end
+    end
+  end
+end
+
+zmin, zmax = plMinMax2dGrid(z)
+step = (zmax - zmin) / (LEVELS + 1)
+clevel = []
+LEVELS.times do |i|
+  clevel[i] = zmin + step + step * i
+end
+
+cmap1_init()
+2.times do |k|
+  4.times do |i|
+    pladv( 0 )
+    plcol0( 1 )
+    plvpor( 0.0, 1.0, 0.0, 0.9 )
+    plwind( -1.0, 1.0, -1.0, 1.5 )
+    plw3d( 1.0, 1.0, 1.2, -3.0, 3.0, -3.0, 3.0, zmin, zmax, alt[k], az[k] )
+    plbox3( "bnstu", "x axis", 0.0, 0,
+           "bnstu", "y axis", 0.0, 0,
+           "bcdmnstuv", "z axis", 0.0, 4 )
+
+    plcol0( 2 )
+
+    # wireframe plot
+    if ( i == 0 )
+      plmesh( x, y, z, opt[k] )
+
+      # magnitude colored wireframe plot
+    elsif ( i == 1 )
+      plmesh( x, y, z, opt[k] | PL::MAG_COLOR )
+
+      # magnitude colored wireframe plot with sides
+    elsif ( i == 2 )
+      plot3d( x, y, z, opt[k] | PL::MAG_COLOR, 1 )
+
+      # magnitude colored wireframe plot with base contour
+    elsif ( i == 3 )
+      #plmeshc( x, y, z, opt[k] | PL::MAG_COLOR | PL::BASE_CONT, clevel )
+      #plmeshc( x, y, z, opt[k] | PL::MAG_COLOR | PL::SURF_CONT, clevel )
+      plmeshc( x, y, z, opt[k] | PL::MAG_COLOR | PL::TOP_CONT, clevel )
+    end
+
+    plcol0( 3 )
+    plmtex( "t", 1.0, 0.5, 0.5, title[k] )
+  end
+end
+
+# Clean up
+plend