Provided by: pdl_2.4.7+dfsg-2ubuntu5_amd64 bug

NAME

       PDL::Graphics::PLplot - Object-oriented interface from perl/PDL to the PLPLOT plotting
       library

SYNOPSIS

         use PDL;
         use PDL::Graphics::PLplot;

         my $pl = PDL::Graphics::PLplot->new (DEV => "png", FILE => "test.png");
         my $x  = sequence(10);
         my $y  = $x**2;
         $pl->xyplot($x, $y);
         $pl->close;

       For more information on PLplot, see

        http://www.plplot.org/

       Also see the test file, t/plplot.pl in this distribution for some working examples.

LONG NAMES

       If you are annoyed by the long constructor call, consider installing the aliased CPAN
       package. Using "aliased", the above example becomes

         use PDL;
         use aliased 'PDL::Graphics::PLplot';

         my $pl = PLplot->new (DEV => "png", FILE => "test.png");
         my $x  = sequence(10);
         # etc, as above

DESCRIPTION

       This is the PDL interface to the PLplot graphics library.  It provides a familiar
       'perlish' Object Oriented interface as well as access to the low-level PLplot commands
       from the C-API.

OPTIONS

       The following options are supported.  Most options can be used with any function.  A few
       are only supported on the call to 'new'.

   Options used upon creation of a PLplot object (with 'new'):
       BACKGROUND

       Set the color for index 0, the plot background

       DEV

       Set the output device type.  To see a list of allowed types, try:

         PDL::Graphics::PLplot->new();

          PDL::Graphics::PLplot->new(DEV => 'png', FILE => 'test.png');

       FILE

       Set the output file or display.  For file output devices, sets the output file name.  For
       graphical displays (like 'xwin') sets the name of the display, eg
       ('hostname.foobar.com:0')

          PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png');
          PDL::Graphics::PLplot->new(DEV => 'xwin', FILE => ':0');

       OPTS

       Set plotting options.  See the PLplot documentation for the complete listing of available
       options.  The value of 'OPTS' must be a hash reference, whose keys are the names of the
       options.  For instance, to obtain PostScript fonts with the ps output device, use:

          PDL::Graphics::PLplot->new(DEV => 'ps', OPTS => {drvopt => 'text=1'});

       MEM

       This option is used in conjunction with "DEV => 'mem'".  This option takes as input a PDL
       image and allows one to 'decorate' it using PLplot.  The 'decorated' PDL image can then be
       written to an image file using, for example, PDL::IO::Pic.  This option may not be
       available if plplot does not include the 'mem' driver.

         # read in Earth image and draw an equator.
         my $pl = PDL::Graphics::PLplot->new (MEM => $earth, DEV => 'mem');
         my $x  = pdl(-180, 180);
         my $y  = zeroes(2);
         $pl->xyplot($x, $y,
                     BOX => [-180,180,-90,90],
                     VIEWPORT => [0.0, 1.0, 0.0, 1.0],
                     XBOX => '', YBOX => '',
                     PLOTTYPE => 'LINE');
         $pl->close;

       FRAMECOLOR

       Set color index 1, the frame color

       JUST

       A flag used to specify equal scale on the axes.  If this is not specified, the default is
       to scale the axes to fit best on the page.

         PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png', JUST => 1);

       ORIENTATION

       The orientation of the plot:

         0 --   0 degrees (landscape mode)
         1 --  90 degrees (portrait mode)
         2 -- 180 degrees (seascape mode)
         3 -- 270 degrees (upside-down mode)

       Intermediate values (0.2) are acceptable if you are feeling daring.

         # portrait orientation
         PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png', ORIENTATION => 1);

       PAGESIZE

       Set the size in pixels of the output page.

         # PNG 500 by 600 pixels
         PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png', PAGESIZE => [500,600]);

       SUBPAGES

       Set the number of sub pages in the plot, [$nx, $ny]

         # PNG 300 by 600 pixels
         # Two subpages stacked on top of one another.
         PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png', PAGESIZE => [300,600],
                                                     SUBPAGES => [1,2]);

   Options used after initialization (after 'new')
       BOX

       Set the plotting box in world coordinates.  Used to explicitly set the size of the
       plotting area.

        my $pl = PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png');
        $pl->xyplot ($x, $y, BOX => [0,100,0,200]);

       CHARSIZE

       Set the size of text in multiples of the default size.  "CHARSIZE => 1.5" gives characters
       1.5 times the normal size.

       COLOR

       Set the current color for plotting and character drawing.  Colors are specified not as
       color indices but as RGB triples.  Some pre-defined triples are included:

         BLACK        GREEN        WHEAT        BLUE
         RED          AQUAMARINE   GREY         BLUEVIOLET
         YELLOW       PINK         BROWN        CYAN
         TURQUOISE    MAGENTA      SALMON       WHITE
         ROYALBLUE    DEEPSKYBLUE  VIOLET       STEELBLUE1
         DEEPPINK     MAGENTA      DARKORCHID1  PALEVIOLETRED2
         TURQUOISE1   LIGHTSEAGREEN SKYBLUE     FORESTGREEN
         CHARTREUSE3  GOLD2        SIENNA1      CORAL
         HOTPINK      LIGHTCORAL   LIGHTPINK1   LIGHTGOLDENROD

        # These two are equivalent:
        $pl->xyplot ($x, $y, COLOR => 'YELLOW');
        $pl->xyplot ($x, $y, COLOR => [0,255,0]);

       LINEWIDTH

       Set the line width for plotting.  Values range from 1 to a device dependent maximum.

       LINESTYLE

       Set the line style for plotting.  Pre-defined line styles use values 1 to 8, one being a
       solid line, 2-8 being various dashed patterns.

       MAJTICKSIZE

       Set the length of major ticks as a fraction of the default setting.  One (default) means
       leave these ticks the normal size.

       MINTICKSIZE

       Set the length of minor ticks (and error bar terminals) as a fraction of the default
       setting.  One (default) means leave these ticks the normal size.

       NXSUB

       The number of minor tick marks between each major tick mark on the X axis.  Specify zero
       (default) to let PLplot compute this automatically.

       NYSUB

       The number of minor tick marks between each major tick mark on the Y axis.  Specify zero
       (default) to let PLplot compute this automatically.

       PALETTE

       Load pre-defined color map 1 color ranges.  Currently, values include:

         RAINBOW   -- from Red to Violet through the spectrum
         REVERSERAINBOW   -- Violet through Red
         GREYSCALE -- from black to white via grey.
         REVERSEGREYSCALE -- from white to black via grey.
         GREENRED  -- from green to red
         REDGREEN  -- from red to green

        # Plot x/y points with the z axis in color
        $pl->xyplot ($x, $y, PALETTE => 'RAINBOW', PLOTTYPE => 'POINTS', COLORMAP => $z);

       PLOTTYPE

       Specify which type of XY plot is desired:

         LINE       -- A line
         POINTS     -- A bunch of symbols
         LINEPOINTS -- both

       SUBPAGE

       Set which subpage to plot on.  Subpages are numbered 1 to N.  A zero can be specified
       meaning 'advance to the next subpage' (just a call to pladv()).

         my $pl = PDL::Graphics::PLplot->new(DEV      => 'png',
                                               FILE     => 'test.png',
                                               SUBPAGES => [1,2]);
         $pl->xyplot ($x, $y, SUBPAGE => 1);
         $pl->xyplot ($a, $b, SUBPAGE => 2);

       SYMBOL

       Specify which symbol to use when plotting "PLOTTYPE => 'POINTS'".  A large variety of
       symbols are available, see: http://plplot.sourceforge.net/examples-data/demo07/x07.*.png,
       where * is 01 - 17.  You are most likely to find good plotting symbols in the 800s:
       http://plplot.sourceforge.net/examples-data/demo07/x07.06.png

       SYMBOLSIZE

       Specify the size of symbols plotted in multiples of the default size (1).  Value are real
       numbers from 0 to large.

       TEXTPOSITION

       Specify the placement of text.  Either relative to border, specified as:

        [$side, $disp, $pos, $just]

       Where

         side = 't', 'b', 'l', or 'r' for top, bottom, left and right
         disp is the number of character heights out from the edge
         pos  is the position along the edge of the viewport, from 0 to 1.
         just tells where the reference point of the string is: 0 = left, 1 = right, 0.5 = center.

       or inside the plot window, specified as:

        [$x, $y, $dx, $dy, $just]

       Where

         x  = x coordinate of reference point of string.
         y  = y coordinate of reference point of string.
         dx   Together with dy, this specifies the inclination of the string.
              The baseline of the string is parallel to a line joining (x, y) to (x+dx, y+dy).
         dy   Together with dx, this specifies the inclination of the string.
         just Specifies the position of the string relative to its reference point.
              If just=0, the reference point is at the left and if just=1,
              it is at the right of the string. Other values of just give
              intermediate justifications.

        # Plot text on top of plot
        $pl->text ("Top label",  TEXTPOSITION => ['t', 4.0, 0.5, 0.5]);

        # Plot text in plotting area
        $pl->text ("Line label", TEXTPOSITION => [50, 60, 5, 5, 0.5]);

       TITLE

       Add a title on top of a plot.

        # Plot text on top of plot
        $pl->xyplot ($x, $y, TITLE => 'X vs. Y');

       VIEWPORT

       Set the location of the plotting window on the page.  Takes a four element array ref
       specifying:

        xmin -- The coordinate of the left-hand edge of the viewport. (0 to 1)
        xmax -- The coordinate of the right-hand edge of the viewport. (0 to 1)
        ymin -- The coordinate of the bottom edge of the viewport. (0 to 1)
        ymax -- The coordinate of the top edge of the viewport. (0 to 1)

       You will need to use this to make color keys or insets.

        # Make a small plotting window in the lower left of the page
        $pl->xyplot ($x, $y, VIEWPORT => [0.1, 0.5, 0.1, 0.5]);

        # Also useful in creating color keys:
        $pl->xyplot   ($x, $y, PALETTE => 'RAINBOW', PLOTTYPE => 'POINTS', COLORMAP => $z);
        $pl->colorkey ($z, 'v', VIEWPORT => [0.93, 0.96, 0.15, 0.85]);

        # Plot an inset; first the primary data and then the inset. In this
        # case, the inset contains a selection of the orignal data
        $pl->xyplot ($x, $y);
        $pl->xyplot (where($x, $y, $x < 1.2), VIEWPORT => [0.7, 0.9, 0.6, 0.8]);

       XBOX

       Specify how to label the X axis of the plot as a string of option letters:

         a: Draws axis, X-axis is horizontal line (y=0), and Y-axis is vertical line (x=0).
         b: Draws bottom (X) or left (Y) edge of frame.
         c: Draws top (X) or right (Y) edge of frame.
         f: Always use fixed point numeric labels.
         g: Draws a grid at the major tick interval.
         h: Draws a grid at the minor tick interval.
         i: Inverts tick marks, so they are drawn outwards, rather than inwards.
         l: Labels axis logarithmically. This only affects the labels, not the data,
            and so it is necessary to compute the logarithms of data points before
            passing them to any of the drawing routines.
         m: Writes numeric labels at major tick intervals in the
            unconventional location (above box for X, right of box for Y).
         n: Writes numeric labels at major tick intervals in the conventional location
            (below box for X, left of box for Y).
         s: Enables subticks between major ticks, only valid if t is also specified.
         t: Draws major ticks.

       The default is 'BCNST' which draws lines around the plot, draws major and minor ticks and
       labels major ticks.

        # plot two lines in a box with independent X axes labeled
        # differently on top and bottom
        $pl->xyplot($x1, $y, XBOX  => 'bnst',  # bottom line, bottom numbers, ticks, subticks
                             YBOX  => 'bnst'); # left line, left numbers, ticks, subticks
        $pl->xyplot($x2, $y, XBOX => 'cmst', # top line, top numbers, ticks, subticks
                             YBOX => 'cst',  # right line, ticks, subticks
                             BOX => [$x2->minmax, $y->minmax]);

       XERRORBAR

       Used only with "xyplot".  Draws horizontal error bars at all points ($x, $y) in the plot.
       Specify a PDL containing the same number of points as $x and $y which specifies the width
       of the error bar, which will be centered at ($x, $y).

       XLAB

       Specify a label for the X axis.

       XTICK

       Interval (in graph units/world coordinates) between major x axis tick marks.  Specify zero
       (default) to allow PLplot to compute this automatically.

       YBOX

       Specify how to label the Y axis of the plot as a string of option letters.  See "XBOX".

       YERRORBAR

       Used only for xyplot.  Draws vertical error bars at all points ($x, $y) in the plot.
       Specify a PDL containing the same number of points as $x and $y which specifies the width
       of the error bar, which will be centered at ($x, $y).

       YLAB

       Specify a label for the Y axis.

       YTICK

       Interval (in graph units/world coordinates) between major y axis tick marks.  Specify zero
       (default) to allow PLplot to compute this automatically.

       ZRANGE

       For "xyplot" (when "COLORMAP" is specified), for "shadeplot" and for "colorkey".
       Normally, the range of the Z variable (color) is taken as "$z->minmax".  If a different
       range is desired, specify it in "ZRANGE", like so:

         $pl->shadeplot ($z, $nlevels, PALETTE => 'GREENRED', ZRANGE => [0,100]);

       or

         $pl->xyplot ($x, $y, PALETTE  => 'RAINBOW', PLOTTYPE => 'POINTS',
                              COLORMAP => $z,        ZRANGE => [-90,-20]);
         $pl->colorkey  ($z, 'v', VIEWPORT => [0.93, 0.96, 0.13, 0.85],
                              ZRANGE => [-90,-20]);

METHODS

       These are the high-level, object oriented methods for PLplot.

   new
       Create an object representing a plot.

        Arguments:
        none.

        Supported options:
        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

         my $pl = PDL::Graphics::PLplot->new(DEV => 'png',  FILE => 'test.png');

   setparm
       Set options for a plot object.

        Arguments:
        none.

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         $pl->setparm (TEXTSIZE => 2);

   xyplot
       Plot XY lines and/or points.  Also supports color scales for points.  This function works
       with bad values.  If a bad value is specified for a points plot, it is omitted.  If a bad
       value is specified for a line plot, the bad value makes a gap in the line.  This is useful
       for drawing maps; for example $x and $y can be the continent boundary latitude and
       longitude.

        Arguments:
        $x, $y

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         $pl->xyplot($x, $y, PLOTTYPE => 'POINTS', COLOR => 'BLUEVIOLET', SYMBOL => 1, SYMBOLSIZE => 4);
         $pl->xyplot($x, $y, PLOTTYPE => 'LINEPOINTS', COLOR => [50,230,30]);
         $pl->xyplot($x, $y, PALETTE => 'RAINBOW', PLOTTYPE => 'POINTS', COLORMAP => $z);

   stripplots
       Plot a set of strip plots with a common X axis, but with different Y axes.  Looks like a
       stack of long, thin XY plots, all line up on the same X axis.

        Arguments:
        $xs -- 1D PDL with common X axis values, length = N
        $ys -- reference to a list of 1D PDLs with Y-axis values, length = N
               or 2D PDL with N x M elements
        -- OR --
        $xs -- reference to a list of 1D PDLs with X-axis values
        $ys -- reference to a list of 1D PDLs with Y-axis values
        %opts -- Options hash

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         my $x  = sequence(20);
         my $y1  = $x**2;
         my $y2  = sqrt($x);
         my $y3  = $x**3;
         my $y4  = sin(($x/20) * 2 * $pi);
         $ys  = cat($y1, $y2, $y3, $y4);
         $pl->stripplots($x, $ys, PLOTTYPE => 'LINE', TITLE => 'functions',
                                  YLAB     => ['x**2', 'sqrt(x)', 'x**3', 'sin(x/20*2pi)'],
                                  COLOR    => ['GREEN', 'DEEPSKYBLUE', 'DARKORCHID1', 'DEEPPINK'], XLAB => 'X label');
         # Equivalent to above:
         $pl->stripplots($x, [$y1, $y2, $y3, $y4],
                                  PLOTTYPE => 'LINE', TITLE => 'functions',
                                  YLAB     => ['x**2', 'sqrt(x)', 'x**3', 'sin(x/20*2pi)'],
                                  COLOR    => ['GREEN', 'DEEPSKYBLUE', 'DARKORCHID1', 'DEEPPINK'], XLAB => 'X label');

         # Here's something a bit different. Notice that different xs have
         # different lengths.
         $x1  = sequence(20);
         $y1  = $x1**2;

         $x2  = sequence(18);
         $y2  = sqrt($x2);

         $x3  = sequence(24);
         $y3  = $x3**3;

         my $x4  = sequence(27);
         $a  = ($x4/20) * 2 * $pi;
         my $y4  = sin($a);

         $xs  = [$x1, $x2, $x3, $x4];
         $ys  = [$y1, $y2, $y3, $y4];
         $pl->stripplots($xs, $ys, PLOTTYPE => 'LINE', TITLE => 'functions',
                       YLAB => ['x**2', 'sqrt(x)', 'x**3', 'sin(x/20*2pi)'],
                                COLOR => ['GREEN', 'DEEPSKYBLUE', 'DARKORCHID1', 'DEEPPINK'], XLAB => 'X label');

       In addition, COLOR may be specified as a reference to a list of colors.  If this is done,
       the colors are applied separately to each plot.

       Also, the options Y_BASE and Y_GUTTER can be specified.  Y_BASE gives the Y offset of the
       bottom of the lowest plot (0-1, specified like a VIEWPORT, defaults to 0.1) and Y_GUTTER
       gives the gap between the graphs (0-1, default = 0.02).

   colorkey
       Plot a color key showing which color represents which value

        Arguments:
        $range   : A PDL which tells the range of the color values
        $orientation : 'v' for vertical color key, 'h' for horizontal

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         # Plot X vs. Y with Z shown by the color.  Then plot
         # vertical key to the right of the original plot.
         $pl->xyplot ($x, $y, PALETTE => 'RAINBOW', PLOTTYPE => 'POINTS', COLORMAP => $z);
         $pl->colorkey ($z, 'v', VIEWPORT => [0.93, 0.96, 0.15, 0.85]);

   shadeplot
       Create a shaded contour plot of 2D PDL 'z' with 'nsteps' contour levels.  Linear scaling
       is used to map the coordinates of Z(X, Y) to world coordinates via the "BOX" option.

        Arguments:
        $z : A 2D PDL which contains surface values at each XY coordinate.
        $nsteps : The number of contour levels requested for the plot.

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         # vertical key to the right of the original plot.
         # The BOX must be specified to give real coordinate values to the $z array.
         $pl->shadeplot ($z, $nsteps, BOX => [-1, 1, -1, 1], PALETTE => 'RAINBOW', ZRANGE => [0,100]);
         $pl->colorkey  ($z, 'v', VIEWPORT => [0.93, 0.96, 0.15, 0.85], ZRANGE => [0,100]);

   histogram
       Create a histogram of a 1-D variable.

        Arguments:
        $x : A 1D PDL
        $nbins : The number of bins to use in the histogram.

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         $pl->histogram ($x, $nbins, BOX => [$min, $max, 0, 100]);

   bargraph
       Simple utility to plot a bar chart with labels on the X axis.  The usual options can be
       specified, plus one other:  MAXBARLABELS specifies the maximum number of labels to allow
       on the X axis.  The default is 20.  If this value is exceeded, then every other label is
       plotted.  If twice MAXBARLABELS is exceeded, then only every third label is printed, and
       so on.

        Arguments:
        $labels -- A reference to a perl list of strings.
        $values -- A PDL of values to be plotted.

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         $labels = ['one', 'two', 'three'];
         $values = pdl(1, 2, 3);

         # Note if TEXTPOSITION is specified, it must be in 4 argument mode (border mode):
         # [$side, $disp, $pos, $just]
         #
         # Where side = 't', 'b', 'l', or 'r' for top, bottom, left and right
         #              'tv', 'bv', 'lv' or 'rv' for top, bottom, left or right perpendicular to the axis.
         #
         #     disp is the number of character heights out from the edge
         #     pos  is the position along the edge of the viewport, from 0 to 1.
         #     just tells where the reference point of the string is: 0 = left, 1 = right, 0.5 = center.
         #
         # The '$pos' entry will be ignored (computed by the bargraph routine)
         $pl->bargraph($labels, $values, MAXBARLABELS => 30, TEXTPOSITION => ['bv', 0.5, 1.0, 1.0]);

   text
       Write text on a plot.  Text can either be written with respect to the borders or at an
       arbitrary location and angle (see the "TEXTPOSITION" entry).

        Arguments:
        $t : The text.

        Supported options:
        All options except:

        BACKGROUND
        DEV
        FILE
        FRAMECOLOR
        JUST
        PAGESIZE
        SUBPAGES

       (These must be set in call to 'new'.)

         $pl->text("Count", COLOR => 'PINK',
                   TEXTPOSITION => ['t', 3, 0.5, 0.5]); # top, 3 units out, string ref. pt in
                                                        # center of string, middle of axis

   close
       Close a PLplot object, writing out the file and cleaning up.

       Arguments: None

       Returns: Nothing

       This closing of the PLplot object can be done explicitly though the 'close' method.
       Alternatively, a DESTROY block does an automatic close whenever the PLplot object passes
       out of scope.

         $pl->close;

FUNCTIONS

       The PDL low-level interface to the PLplot library closely mimics the C API.  Users are
       referred to the PLplot User's Manual, distributed with the source PLplot tarball.  This
       manual is also available on-line at the PLplot web site (<http://www.plplot.org/>).

       There are though two differences in way the functions are called.  The first one is due to
       a limitation in the pp_def wrapper of PDL, which forces all the non-piddle arguments to be
       at the end of the arguments list.  It is the case of strings ("char *") arguments in the C
       API.  This affects the following functions [shown below with their prototypes in PDL, with
       arguments preceded by "(pdl)" are piddle-convertible; see the PLplot manual for the
       meaning of the arguments]:

         plaxes ((pdl) x0, (pdl) y0, (pdl) xtick, (pdl) nxsub, (pdl) ytick,
                 (pdl) nysub, (string) xopt, (string (yopt))
         plbox ((pdl) xtick, (pdl) nxsub, (pdl) ytick, (pdl) nysub,
                (string) xopt, (string) yopt)
         plbox3 ((pdl) xtick, (pdl) nsubx, (pdl) ytick, (pdl) nsuby,
                 (pdl) ztick, (pdl) nsubz, (string) xopt, (string) xlabel,
                 (string) yopt, (string) ylabel, (string) zopt,
                 (string) zlabel)
         plmtex ((pdl) disp, (pdl) pos, (pdl) just, (string) side),
                 (string) text);
         plstart ((pdl) nx, (pdl) ny, (string) devname);

       The second notable different between the C and the PDL APIs is that many of the PDL calls
       do not need arguments to specify the size of the the vectors and/or matrices being passed.
       This size parameters are deduced from the size of the piddles, when possible.  For now,
       the following interfaces are affected:

         plcont (f, kx, lx, ky, ly, clevel)
         plfill (x, y)
         plhist (data, datmin, datmax, nbin, oldwin)
         plline (x, y)
         plline3 (x, y, z)
         plpoly3 (x, y, z, draw, ifcc)
         plmesh (x, y, z, opt)
         plmeshc (x, y, z, opt, clevel)
         plot3d (x, y, z, opt, side)
         plpoin (x, y, code)
         plpoin3 (x, y, z, code)
         plscmap1l (itype, intensity, coord1, coord2, coord3, rev)
         plstyl (mark, space)
         plsym (x, y, code)

       Some of the API functions implemented in PDL have other specificities in comparison with
       the C API and will be discussed below.

   pladv
         Signature: (int page())

       info not available

       pladv does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plarrows
         Signature: (double u(dima);double v(dima);double x(dima);double y(dima);int n();double scale();double dx();double dy())

       info not available

       plarrows does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plaxes
         Signature: (double xzero();double yzero();double xtick();int nxsub();double ytick();int nysub(); char *xopt;char *yopt)

       info not available

       plaxes does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plbin
         Signature: (int nbin();double x(dima);double y(dima);int center())

       info not available

       plbin does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plbox
         Signature: (double xtick();int nxsub();double ytick();int nysub(); char *xopt;char *yopt)

       info not available

       plbox does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plbox3
         Signature: (double xtick();int nsubx();double ytick();int nsuby();double ztick();int nsubz(); char *xopt;char *xlabel;char *yopt;char *ylabel;char *zopt;char *zlabel)

       info not available

       plbox3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plcol0
         Signature: (int icolzero())

       info not available

       plcol0 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plcol1
         Signature: (double colone())

       info not available

       plcol1 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plcpstrm
         Signature: (int iplsr();int flags())

       info not available

       plcpstrm does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   pldid2pc
         Signature: (double xmin(dima);double ymin(dima);double xmax(dima);double ymax(dima))

       info not available

       pldid2pc does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   pldip2dc
         Signature: (double xmin(dima);double ymin(dima);double xmax(dima);double ymax(dima))

       info not available

       pldip2dc does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plenv
         Signature: (double xmin();double xmax();double ymin();double ymax();int just();int axis())

       info not available

       plenv does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plenv0
         Signature: (double xmin();double xmax();double ymin();double ymax();int just();int axis())

       info not available

       plenv0 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plerrx
         Signature: (int n();double xmin(dima);double xmax(dima);double y(dima))

       info not available

       plerrx does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plerry
         Signature: (int n();double x(dima);double ymin(dima);double ymax(dima))

       info not available

       plerry does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plfill3
         Signature: (int n();double x(dima);double y(dima);double z(dima))

       info not available

       plfill3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plfont
         Signature: (int ifont())

       info not available

       plfont does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plfontld
         Signature: (int fnt())

       info not available

       plfontld does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgchr
         Signature: (double [o]p_def();double [o]p_ht())

       info not available

       plgchr does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgcompression
         Signature: (int [o]compression())

       info not available

       plgcompression does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgdidev
         Signature: (double [o]p_mar();double [o]p_aspect();double [o]p_jx();double [o]p_jy())

       info not available

       plgdidev does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgdiori
         Signature: (double [o]p_rot())

       info not available

       plgdiori does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgdiplt
         Signature: (double [o]p_xmin();double [o]p_ymin();double [o]p_xmax();double [o]p_ymax())

       info not available

       plgdiplt does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgfam
         Signature: (int [o]p_fam();int [o]p_num();int [o]p_bmax())

       info not available

       plgfam does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plglevel
         Signature: (int [o]p_level())

       info not available

       plglevel does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgpage
         Signature: (double [o]p_xp();double [o]p_yp();int [o]p_xleng();int [o]p_yleng();int [o]p_xoff();int [o]p_yoff())

       info not available

       plgpage does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgspa
         Signature: (double [o]xmin();double [o]xmax();double [o]ymin();double [o]ymax())

       info not available

       plgspa does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgvpd
         Signature: (double [o]p_xmin();double [o]p_xmax();double [o]p_ymin();double [o]p_ymax())

       info not available

       plgvpd does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgvpw
         Signature: (double [o]p_xmin();double [o]p_xmax();double [o]p_ymin();double [o]p_ymax())

       info not available

       plgvpw does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgxax
         Signature: (int [o]p_digmax();int [o]p_digits())

       info not available

       plgxax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgyax
         Signature: (int [o]p_digmax();int [o]p_digits())

       info not available

       plgyax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgzax
         Signature: (int [o]p_digmax();int [o]p_digits())

       info not available

       plgzax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plhls
         Signature: (double h();double l();double s())

       info not available

       plhls does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   pljoin
         Signature: (double xone();double yone();double xtwo();double ytwo())

       info not available

       pljoin does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   pllightsource
         Signature: (double x();double y();double z())

       info not available

       pllightsource does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   pllsty
         Signature: (int lin())

       info not available

       pllsty does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plmtex
         Signature: (double disp();double pos();double just(); char *side;char *text)

       info not available

       plmtex does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plmtex3
         Signature: (double disp();double pos();double just(); char *side;char *text)

       info not available

       plmtex3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plpat
         Signature: (int nlin();int inc(dima);int del(dima))

       info not available

       plpat does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plprec
         Signature: (int setp();int prec())

       info not available

       plprec does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plpsty
         Signature: (int patt())

       info not available

       plpsty does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plptex
         Signature: (double x();double y();double dx();double dy();double just(); char *text)

       info not available

       plptex does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plptex3
         Signature: (double x();double y();double z();double dx();double dy();double dz();double sx();double sy();double sz();double just(); char *text)

       info not available

       plptex3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plrgb
         Signature: (double r();double g();double b())

       info not available

       plrgb does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plrgb1
         Signature: (int r();int g();int b())

       info not available

       plrgb1 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plschr
         Signature: (double def();double scale())

       info not available

       plschr does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plscmap0n
         Signature: (int ncolzero())

       info not available

       plscmap0n does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap1n
         Signature: (int ncolone())

       info not available

       plscmap1n does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscol0
         Signature: (int icolzero();int r();int g();int b())

       info not available

       plscol0 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plscolbg
         Signature: (int r();int g();int b())

       info not available

       plscolbg does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscolor
         Signature: (int color())

       info not available

       plscolor does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscompression
         Signature: (int compression())

       info not available

       plscompression does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsdidev
         Signature: (double mar();double aspect();double jx();double jy())

       info not available

       plsdidev does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsdimap
         Signature: (int dimxmin();int dimxmax();int dimymin();int dimymax();double dimxpmm();double dimypmm())

       info not available

       plsdimap does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsdiori
         Signature: (double rot())

       info not available

       plsdiori does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsdiplt
         Signature: (double xmin();double ymin();double xmax();double ymax())

       info not available

       plsdiplt does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsdiplz
         Signature: (double xmin();double ymin();double xmax();double ymax())

       info not available

       plsdiplz does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   pl_setcontlabelparam
         Signature: (double offset();double size();double spacing();int active())

       info not available

       pl_setcontlabelparam does not process bad values.  It will set the bad-value flag of all
       output piddles if the flag is set for any of the input piddles.

   pl_setcontlabelformat
         Signature: (int lexp();int sigdig())

       info not available

       pl_setcontlabelformat does not process bad values.  It will set the bad-value flag of all
       output piddles if the flag is set for any of the input piddles.

   plsfam
         Signature: (int fam();int num();int bmax())

       info not available

       plsfam does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsmaj
         Signature: (double def();double scale())

       info not available

       plsmaj does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsmin
         Signature: (double def();double scale())

       info not available

       plsmin does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsori
         Signature: (int ori())

       info not available

       plsori does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plspage
         Signature: (double xp();double yp();int xleng();int yleng();int xoff();int yoff())

       info not available

       plspage does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plspause
         Signature: (int pause())

       info not available

       plspause does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsstrm
         Signature: (int strm())

       info not available

       plsstrm does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plssub
         Signature: (int nx();int ny())

       info not available

       plssub does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plssym
         Signature: (double def();double scale())

       info not available

       plssym does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plstar
         Signature: (int nx();int ny())

       info not available

       plstar does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plstart
         Signature: (int nx();int ny(); char *devname)

       info not available

       plstart does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plstripa
         Signature: (int id();int pen();double x();double y())

       info not available

       plstripa does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plstripd
         Signature: (int id())

       info not available

       plstripd does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsvpa
         Signature: (double xmin();double xmax();double ymin();double ymax())

       info not available

       plsvpa does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsxax
         Signature: (int digmax();int digits())

       info not available

       plsxax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsxwin
         Signature: (int window_id())

       info not available

       plsxwin does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsyax
         Signature: (int digmax();int digits())

       info not available

       plsyax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plszax
         Signature: (int digmax();int digits())

       info not available

       plszax does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plvasp
         Signature: (double aspect())

       info not available

       plvasp does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plvpas
         Signature: (double xmin();double xmax();double ymin();double ymax();double aspect())

       info not available

       plvpas does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plvpor
         Signature: (double xmin();double xmax();double ymin();double ymax())

       info not available

       plvpor does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plw3d
         Signature: (double basex();double basey();double height();double xminzero();double xmaxzero();double yminzero();double ymaxzero();double zminzero();double zmaxzero();double alt();double az())

       info not available

       plw3d does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plwid
         Signature: (int width())

       info not available

       plwid does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plwind
         Signature: (double xmin();double xmax();double ymin();double ymax())

       info not available

       plwind does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plP_gpixmm
         Signature: (double p_x(dima);double p_y(dima))

       info not available

       plP_gpixmm does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscolbga
         Signature: (int r();int g();int b();double a())

       info not available

       plscolbga does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscol0a
         Signature: (int icolzero();int r();int g();int b();double a())

       info not available

       plscol0a does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plline
         Signature: (x(n); y(n))

       Draws line segments along (x1,y1)->(x2,y2)->(x3,y3)->...

       If the nth value of either x or y are bad, then it will be skipped, breaking the line.  In
       this way, you can specify multiple line segments with a single pair of x and y piddles.

       The usage is straight-forward:

        plline($x, $y);

       For example:

        # Draw a sine wave
        $x = sequence(100)/10;
        $y = sin($x);

        # Draws the sine wave:
        plline($x, $y);

        # Set values above 3/4 to 'bad', effectively drawing a bunch of detached,
        # capped waves
        $y->setbadif($y > 3/4);
        plline($x, $y);

       plline does handle bad values.  It will set the bad-value flag of all output piddles if
       the flag is set for any of the input piddles.

   plcolorpoints
         Signature: (x(n); y(n); z(n); int sym(); minz(); maxz())

       PDL-specific: Implements what amounts to a threaded version of plsym.

       Bad values for z are simply skipped; all other bad values are not processed.

       In the following usage, all of the piddles must have the same dimensions:

        plcolorpoints($x, $y, $z, $symbol_index, $minz, $maxz)

       For example:

        # Generate a parabola some points
        my $x = sequence(30) / 3;   # Regular sampling
        my $y = $x**2;              # Parabolic y
        my $z = 30 - $x**3;         # Cubic coloration
        my $symbols = floor($x);    # Use different symbols for each 1/3 of the plot
                                    #  These should be integers.

        plcolorpoints($x, $y, $z, $symbols, -5, 20);  # Thread over everything
        plcolorpoints($x, $y, 1, 1, -1, 2);           # same color and symbol for all

       plcolorpoints does handle bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plsmem
         Signature: (int maxx();int maxy();image(3,x,y))

       info not available

       plsmem does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plfbox
         Signature: (xo(); yo())

       info not available

       plfbox does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plParseOpts
         Signature: (int [o] retval(); SV* argv; int mode)

       FIXME: documentation here!

       plParseOpts does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plpoin
         Signature: (x(n); y(n); int code())

       info not available

       plpoin does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plpoin3
         Signature: (x(n); y(n); z(n); int code())

       info not available

       plpoin3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plline3
         Signature: (x(n); y(n); z(n))

       info not available

       plline3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plpoly3
         Signature: (x(n); y(n); z(n); int draw(m); int ifcc())

       info not available

       plpoly3 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plhist
         Signature: (data(n); datmin(); datmax(); int nbin(); int oldwin())

       info not available

       plhist does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plfill
         Signature: (x(n); y(n))

       info not available

       plfill does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsym
         Signature: (x(n); y(n); int code())

       info not available

       plsym does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsurf3d
         Signature: (x(nx); y(ny); z(nx,ny); int opt(); clevel(nlevel))

       info not available

       plsurf3d does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plstyl
         Signature: (int mark(nms); int space(nms))

       info not available

       plstyl does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plseed
         Signature: (int seed())

       info not available

       plseed does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plrandd
         Signature: (double [o]rand())

       info not available

       plrandd does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plAllocGrid
         Signature: (double xg(nx); double yg(ny); int [o] grid())

       FIXME: documentation here!

       plAllocGrid does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plAlloc2dGrid
         Signature: (double xg(nx,ny); double yg(nx,ny); int [o] grid())

       FIXME: documentation here!

       plAlloc2dGrid does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   init_pltr
         Signature: (P(); C(); SV* p0; SV* p1; SV* p2)

       FIXME: documentation here!

       init_pltr does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plmap
         Signature: (minlong(); maxlong(); minlat(); maxlat(); SV* mapform; char* type)

       info not available

       plmap does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plmeridians
         Signature: (dlong(); dlat(); minlong(); maxlong(); minlat(); maxlat(); SV* mapform)

       info not available

       plmeridians does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plshades
         Signature: (z(x,y); xmin(); xmax(); ymin(); ymax();
                         clevel(l); int fill_width(); int cont_color();
                         int cont_width(); int rectangular(); SV* defined; SV* pltr; SV* pltr_data)

       info not available

       plshades does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plcont
         Signature: (f(nx,ny); int kx(); int lx(); int ky(); int ly(); clevel(nlevel); SV* pltr; SV* pltr_data)

       FIXME: documentation here!

       plcont does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plmesh
         Signature: (x(nx); y(ny); z(nx,ny); int opt())

       FIXME: documentation here!

       plmesh does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plmeshc
         Signature: (x(nx); y(ny); z(nx,ny); int opt(); clevel(nlevel))

       FIXME: documentation here!

       plmeshc does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plot3d
         Signature: (x(nx); y(ny); z(nx,ny); int opt(); int side())

       FIXME: documentation here!

       plot3d does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plot3dc
         Signature: (x(nx); y(ny); z(nx,ny); int opt(); clevel(nlevel))

       FIXME: documentation here!

       plot3dc does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plscmap1l
         Signature: (int itype(); isty(n); coord1(n); coord2(n); coord3(n); int rev(nrev))

       FIXME: documentation here!

       plscmap1l does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plshade1
         Signature: (a(nx,ny); left(); right(); bottom(); top(); shade_min();shade_max(); sh_cmap(); sh_color(); sh_width();min_color(); min_width(); max_color(); max_width();rectangular(); SV* defined; SV* pltr; SV* pltr_data)

       FIXME: documentation here!

       plshade1 does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plimage
         Signature: (idata(nx,ny); xmin(); xmax(); ymin(); ymax();zmin(); zmax(); Dxmin(); Dxmax(); Dymin(); Dymax())

       info not available

       plimage does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plimagefr
         Signature: (idata(nx,ny); xmin(); xmax(); ymin(); ymax();zmin(); zmax(); valuemin(); valuemax(); SV* pltr; SV* pltr_data)

       info not available

       plimagefr does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plxormod
         $status = plxormod ($mode)

       See the PLplot manual for reference.

   plGetCursor
         %gin = plGetCursor ()

       plGetCursor waits for graphics input event and translate to world coordinates and returns
       a hash with the following keys:

           type:      of event (CURRENTLY UNUSED)
           state:     key or button mask
           keysym:    key selected
           button:    mouse button selected
           subwindow: subwindow (alias subpage, alias subplot) number
           string:    translated string
           pX, pY:    absolute device coordinates of pointer
           dX, dY:    relative device coordinates of pointer
           wX, wY:    world coordinates of pointer

       Returns an empty hash if no translation to world coordinates is possible.

   plgstrm
         $strm = plgstrm ()

       Returns the number of the current output stream.

   plgsdev
         $driver = plgdev ()

       Returns the current driver name.

   plmkstrm
         $strm = plmkstrm ()

       Creates a new stream and makes it the default.  Returns the number of the created stream.

   plgver
         $version = plgver ()

       See the PLplot manual for reference.

   plstripc
         Signature: (xmin(); xmax(); xjump(); ymin(); ymax();xlpos(); ylpos(); int y_ascl(); int acc();int colbox(); int collab();int colline(n); int styline(n);  int [o] id(); char* xspec; char* yspec; SV* legline;char* labx; char* laby; char* labtop)

       FIXME: documentation here!

       plstripc does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgriddata
         Signature: (x(npts); y(npts); z(npts); xg(nptsx); yg(nptsy);int type(); data(); [o] zg(nptsx,nptsy))

       FIXME: documentation here!

       plgriddata does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plvect
         Signature: (u(nx,ny); v(nx,ny); scale(); SV* pltr; SV* pltr_data)

       FIXME: documentation here!

       plvect does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsvect
         Signature: (arrowx(npts); arrowy(npts); int fill())

       info not available

       plsvect does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plhlsrgb
         Signature: (double h();double l();double s();double [o]p_r();double [o]p_g();double [o]p_b())

       info not available

       plhlsrgb does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgcol0
         Signature: (int icolzero(); int [o]r(); int [o]g(); int [o]b())

       info not available

       plgcol0 does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plgcolbg
         Signature: (int [o]r(); int [o]g(); int [o]b())

       info not available

       plgcolbg does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap0
         Signature: (int r(n); int g(n); int b(n))

       info not available

       plscmap0 does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap1
         Signature: (int r(n); int g(n); int b(n))

       info not available

       plscmap1 does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgcol0a
         Signature: (int icolzero(); int [o]r(); int [o]g(); int [o]b(); double [o]a())

       info not available

       plgcol0a does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgcolbga
         Signature: (int [o]r(); int [o]g(); int [o]b(); double [o]a())

       info not available

       plgcolbga does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap0a
         Signature: (int r(n); int g(n); int b(n); double a(n))

       info not available

       plscmap0a does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap1a
         Signature: (int r(n); int g(n); int b(n); double a(n))

       info not available

       plscmap1a does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plscmap1la
         Signature: (int itype(); isty(n); coord1(n); coord2(n); coord3(n); coord4(n); int rev(nrev))

       FIXME: documentation here!

       plscmap1la does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

   plgfont
         Signature: (int [o]p_family(); int [o]p_style(); int [o]p_weight())

       info not available

       plgfont does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plsfont
         Signature: (int family(); int style(); int weight())

       info not available

       plsfont does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

   plcalc_world
         Signature: (double rx(); double ry(); double [o]wx(); double [o]wy(); int [o]window())

       info not available

       plcalc_world does not process bad values.  It will set the bad-value flag of all output
       piddles if the flag is set for any of the input piddles.

WARNINGS AND ERRORS

       PLplot gives many errors and warnings.  Some of these are given by the PDL interface while
       others are internal PLplot messages.  Below are some of these messages, and what you need
       to do to address them:

       ·   Box must be a ref to a four element array

           When specifying a box, you must pass a reference to a four-element array, or use an
           anonymous four-element array.

            # Gives trouble:
            $pl->xyplot($x, $y, BOX => (0, 0, 100, 200) );
            # What you meant to say was:
            $pl->xyplot($x, $y, BOX => [0, 0, 100, 200] );

       ·   Too many colors used! (max 15)

AUTHORS

         Doug Hunt <dhunt@ucar.edu>
         Rafael Laboissiere <rlaboiss@users.sourceforge.net>
         David Mertens <mertens2@illinois.edu>

SEE ALSO

       perl(1), PDL(1), <http://www.plplot.org/>

       The other common graphics packages include PDL::PGPLOT and PDL::TriD.