Provided by: libchart-gnuplot-perl_0.20-2_all bug

NAME

       Chart::Gnuplot - Plot graph using Gnuplot in Perl on the fly

SYNOPSIS

           use Chart::Gnuplot;

           # Data
           my @x = (-10 .. 10);
           my @y = (0 .. 20);

           # Create chart object and specify the properties of the chart
           my $chart = Chart::Gnuplot->new(
               output => "fig/simple.png",
               title  => "Simple testing",
               xlabel => "My x-axis label",
               ylabel => "My y-axis label",
               ....
           );

           # Create dataset object and specify the properties of the dataset
           my $dataSet = Chart::Gnuplot::DataSet->new(
               xdata => \@x,
               ydata => \@y,
               title => "Plotting a line from Perl arrays",
               style => "linespoints",
               ....
           );

           # Plot the data set on the chart
           $chart->plot2d($dataSet);

           ##################################################

           # Plot many data sets on a single chart
           $chart->plot2d($dataSet1, $dataSet2, ...);

DESCRIPTION

       This Perl module is to plot graphs uning GNUPLOT on the fly. In order to use this module,
       gnuplot need to be installed. If image format other than PS and EPS is required to
       generate, it is recommended to install the convert program of ImageMagick as well. Please
       refer to "MECHANISM OF THIS MODULE" for details.

       To plot chart using Chart::Gnuplot, a chart object and at least one dataset object are
       required. Information about the chart such as output file, chart title, axes labels and so
       on is specified in the chart object.  Dataset object contains information about the
       dataset to be plotted, including source of the data points, dataset label, color used to
       plot and more.

       After chart object and dataset object(s) are created, the chart can be plotted using the
       plot2d, plot3d or multiplot method of the chart object, e.g.

           # $chart is the chart object
           $chart->plot2d($dataSet1, $dataSet2, ...);

       To illustate the features of Chart::Gnuplot, the best way is to show by examples. A lot of
       examples can be found in SourceForge <http://chartgnuplot.sourceforge.net>.

MECHANISM OF THIS MODULE

       Casual users may skip this session.

       When the plotting method (e.g. plot2d) is called, Chart::Gnuplot would generate a Gnuplot
       script based on the information in the chart object and dataset object. Then it would call
       the Gnuplot program. Unless specified explicitly in terminal of the Chart object,
       Chart::Gnuplot would by default generate the image in PS format first and then convert the
       image (by ImageMagick) based on the extension of the filename. The rationale of this
       approach is that the postscript terminal is so far the best developed teriminal and so
       this would let users to enjoy the power of Gnuplot as much as possible.

       Because the default terminal is postscript, if ImageMagick is not installed, you would
       always need to specify the terminal if the output format is not PS (or EPS).

       On the other hand, for some image formats, e.g. mousing supported SVG, which ImageMagick
       cannot be converted to, the terminal must be set explicitly (e.g., "svg mousing" in this
       case).

CHART OBJECT

       The chart object can be initiated by the c<new> method. Properties of the chart may be
       specified optionally when the object is initiated:

           my $chart = Chart::Gnuplot->new(%options);

   Chart Options
       output

       Output file of the graph. E.g.

           output => "fig/chart.png",

       By default, the image format is detected automatically by the extension of the filename.
       (Please refer to "MECHANISM OF THIS MODULE" for details). However, it can also be changed
       manually by the terminal option or the format conversion methods such as convert and png.

       Some of image formats that can be detected automatically are:

           bmp  : Microsoft Windows bitmap
           epdf : Encapsulated Portable Document Format
           epi  : Encapsulated PostScript Interchange format
           eps  : Encapsulated PostScript
           gif  : Graphics Interchange Format
           jpg  : Joint Photographic Experts Group JFIF format
           pdf  : Portable Document Format
           png  : Portable Network Graphics
           ppm  : Portable Pixmap Format
           ps   : PostScript file
           psd  : Adobe Photoshop bitmap file
           xpm  : X Windows system pixmap

       If the filename has no extension, postscipt format will be output.

       title

       Title of the chart. E.g.,

           title => "Chart title"

       Properties of the chart title can be specified in hash. E.g.,

           title => {
               text => "Chart title",
               font => "arial, 20",
               ....
           }

       Supported properties are:

           text     : title in plain text
           font     : font face (and optionally font size)
           color    : font color
           offset   : offset relative to the default position
           enhanced : title contains subscript/superscipt/greek? (on/off)

       Default values would be used for properties not specified. These properties has no effect
       on the main title of the multi-chart (see multiplot).

       xlabel, ylabel, zlabel

       Label of the x-axis, y-axis and z-axis. E.g.

           xlabel => "Bottom axis label"

       Properties of the axis label can be specified in hash, similar to the chart title.
       Supported properties are:

           text     : title in plain text
           font     : font face (and optionally font size)
           color    : font color
           offset   : offset relative to the default position
           rotate   : rotation in degrees
           enhanced : title contains subscript/superscipt/greek? (on/off)

       x2label, y2label

       Label of the secondary x-axis (displayed on the top of the graph) and the secondary y-axis
       (displayed on the right of the graph). See xlabel.

       xrange, yrange, zrange

       Range of the x-axis, y-axis and z-axis in the plot, e.g.

           xrange => [0, "pi"]

       would make the plot from x = 0 to x = 3.14159...

       x2range, y2range

       Range of the secondary (top horizontal and right vertical) axes of the plot.  See "xrange,
       yrange, zrange".

       trange, urange, vrange

       Range of the parametric parameter (t for 2D plots, while u and v for 3D plots).  See
       "xrange, yrange, zrange".

       xtics, ytics, ztics

       The tics and tic label on the x-axis, y-axis and z-axis. E.g.

          xtics => {
             labels   => [-10, 15, 20, 25],
             labelfmt => "%3f",
             ....
          }

       If you set this to "undef". E.g.,

           xtics => undef

       Then this option will be explicitly unset and the chart will have not have tic marks on
       the specified axis.

       Supported properties are:

           labels    : the locations of the tic labels
           labelfmt  : format of the labels
           font      : font of the labels
           fontsize  : font size of the lebals
           fontcolor : font color of the label
           offset    : position of the tic labels shifted from its default
           rotate    : rotation of the tic labels
           length    : length of the tics
           along     : where the tics are put (axis/border)
           minor     : number of minor tics between adjacant major tics
           mirror    : turn on and off the tic label of the secondary axis. No effect
                     : for C<ztics> (on/off)

       x2tics, y2tics

       The tics and tic label of the secondary axes. See "xtics, ytics, ztics".

       legend

       Legend describing the plots. Supported properties are:

           position : position of the legend
           width    : number of character widths to be added or subtracted to the
                    : region of the legend
           height   : number of character heights to be added or subtracted to the
                    : region of the legend
           align    : alignment of the text label. Left or right (default)
           order    : order of the keys
           title    : title of the legend
           sample   : format of the sample lines
           border   : border of the legend

       See border for the available options of border

       E.g.

           legend => {
              position => "outside bottom",
              width    => 3,
              height   => 4,
              align    => "right",
              order    => "horizontal reverse",
              title    => "Title of the legend",
              sample   => {
                  length   => 3,
                  position => "left",
                  spacing  => 2,
              },
              border   => {
                  linetype => 2,
                  width    => 1,
                  color    => "blue",
              },
           }

       timeaxis

       Specify the axes of which the tic labels are date/time string. Possible values are
       combinations of "x", "y", "x2", and "y2" joined by ",". E.g.

           timeaxis => "x, y2"

       means that the x-axis and y2-axis are data/time axes.

       border

       Border of the graph. Properties supported are:

           sides    : sides on which border is displayed
           linetype : line type
           width    : line width
           color    : line coler

       E.g.

           border => {
               sides    => "bottom, left",
               linetype => 3,
               width    => 2,
               color    => '#ff00ff',
           }

       "sides" tells which side(s) will be displayed. Default is all four borders for 2D plots,
       and four bottom and left vertial borders for 3D plots. Acceptable valurs are the 12-bit
       code (see the Gnuplot manual) or the following names:

           bottom
           left
           top
           right
           bottom left front
           bottom left back
           bottom right front
           bottom right back
           left vertical
           right vertical
           front vertical
           back vertical
           top left front
           top left back
           top right front
           top right back

       If you set this to "undef". E.g.,

           border => undef

       Then this option will be explicitly unset and the chart will have not have any border.

       grid

       Major grid lines. E.g.

           grid => {
               linetype => 'dash',
               width    => 2,
               ....
           }

       Supported properties are:

           linetype : line type of the grid lines (default: dot)
           width    : line width (defaulr: 0)
           color    : line color (default: black)
           xlines   : whether the vertical grid lines are drawn (on/off)
           ylines   : whether the horizontal grid lines are drawn (on/off)

       tmargin, bmargin

       Top and bottom margin (in character height). This option has no effect in 3D plots. E.g.

           tmargin => 10

       lmargin, rmargin

       Left amd right margin (in character width). This option has no effect in 3D plots. See
       "tmargin, bmargin".

       orient

       Orientation of the image. Possible values are "lanscape" (default) and "portrait". E.g.

           orient => "portrait"

       imagesize

       Size (length and height) of the image relative to the default. E.g.

           imagesize => "0.8, 0.5"

       size

       Size of the plot relative to the chart size. This is useful in some multi-plot such as
       inset chart. E.g.

           size => "0.5, 0.4"

       origin

       Origin of the chart. This is useful in some multi-plot such as inset chart.  E.g.

           origin => "0.1, 0.5"

       timestamp

       Time stamp of the plot. To place the time stamp with default setting,

           timestamp => 'on'

       Properties of the time stamp (such as date-time format) can also be set, e.g.

           timestamp => {
              fmt    => '%d/%m/%y %H:%M',
              offset => "10,-3",
              font   => "Helvetica",
           }

       Supported properties are:

           fmt    : date-time format
           offset : offset relative to the default position
           font   : font face (and optionally font size)

       bg

       Background color of the chart. This option has no effect in the sub-chart of multiplot.
       E.g. to give the chart a yellow background,

           bg => "yellow"

       Properties can be specified in hash. E.g.,

           bg => {
               color   => "yellow",
               density => 0.2,
           }

       Supported properties are:

           color   : color (name ot RRGGBB value)
           density : density of the coloring

       plotbg

       Background color of the plot area. This option has no effect in 3D plots. See bg for
       supported properties.

       gnuplot

       The path of Gnuplot executable. This option is useful if you are using Windows or have
       multiple versions of Gnuplot installed. E.g.,

           gnuplot => "C:\Program Files\...\gnuplot\bin\wgnuplot.exe"   # for Windows

       convert

       The path of convert executable of ImageMagick. This option is useful if you have multiple
       convert executables.

       terminal

       The terminal driver that Gnuplot uses. E.g.,

           terminal => 'svg mousing'

       The default value is "postscript enhanced color". Terminal is not necessarily related to
       the output image format. E.g., you may use gif terminal and then convert the image format
       to jpg by the convert() method.

   Chart Options Not Mentioned Above
       If Chart::Gnuplot encounters options not mentions above, it would convert them to Gnuplot
       set statements. E.g. if the chart object is

           $chart = Chart::Gnuplot->new(
               ...
               foo => "FOO",
           );

       the generated Gnuplot statements would be:

           ...
           set foo FOO

       This mechanism lets Chart::Gnuplot support many features not mentioned above (such as
       "cbrange", "samples", "view" and so on).

   Chart Methods
       new

           my $chart = Chart::Gnuplot->new(%options);

       Constructor of the chart object. If no option is specified, default values would be used.
       See "Chart Options" for available options.

       set

       General set methods for arbitrary number of options.

           $chart->set(%options);

       E.g.

           $chart->set(view => '30,60');

       will be translated to the Gnuplot statement

           set view 30,60

       plot2d

           $chart->plot2d(@dataSets);

       Plot the data sets in a 2D chart. Each dataset is represented by a dataset object.

       plot3d

           $chert->plot3d(@dataSets);

       Plot the data sets in a 3D chart. Each dataset is represented by a dataset object.

       multiplot

           $chart->multiplot(@charts);

       Plot multiple charts in the same image.

       animate

       Create animated gif. E.g.

           # Create (main) chart object
           my $chart = Chart::Gnuplot->new(
               output => "animate.gif",
           );

           # Add frames to the (main) chart object
           my $T = 30; # number of frames
           my @c;
           for (my $i = 0; $i < $T; $i++)
           {
               $c[$i] = Chart::Gnuplot->new(xlabel => 'x');
               my $ds = Chart::Gnuplot::DataSet->new(
                   func => "sin($i*2*pi/$T + x)",
               );
               $c[$i]->add2d($ds);
           }

           # Create animation
           $chart->animate(
               charts => \@c,
               delay  => 10,   # delay 0.1 sec between successive images
           );

       Supported properties are:

           charts : chart sequence used to create the animation
           delay  : delay (in units of 0.01 second) between successive images, default
                  : value is 5

       See add2d and add3d.

       add2d

       Add a 2D dataset to a chart without plotting it out immediately. Used with "multiplot" or
       "animate".

       add3d

       Add a 3D dataset to a chart without plotting it out immediately. Used with "multiplot" or
       "animate".

       label

       Add an arbitrary text label. e.g.,

           $chart->label(
               text       => "This is a label",
               position   => "0.2, 3 left",
               offset     => "2,2",
               rotate     => 45,
               font       => "arial, 15",
               fontcolor  => "dark-blue",
               pointtype  => 3,
               pointsize  => 5,
               pointcolor => "blue",
           );

       Supported properties are:

           text       : label text
           position   : position of the label
           offset     : offset relative to the default position
           rotate     : rotation in degrees
           font       : font face (and optionally font size)
           fontcolor  : color of the text
           pointtype  : point type
           pointsize  : point size
           pointcolor : point color

       arrow

       Draw arbitrary arrow. e.g.,

           $chart->arrow(
               from     => "0,2",
               to       => "0.3,0.1",
               linetype => 'dash',
               width    => 2,
               color    => "dark-blue",
               head     => {
                   size  => 2,
                   angle => 30,
               },
           );

       Supported properties are:

           from     : starting position
           to       : ending position (position of the arrow head)
           rto      : ending position relative to the starting position
           linetype : line type
           width    : line width
           color    : color
           head     : arrow head

       Supported properties of the arrow head are:

           size      : size of the head
           angle     : angle (in degree) between the arrow and the head branch
           direction : head direction ('back', 'both' or 'off')

       line

       Draw arbitrary straight line. e.g.,

           $chart->line(
               from     => "0,2",
               to       => "0.3,0.1",
               linetype => 'dash',
               width    => 2,
               color    => "dark-blue",
           );

       Supported properties are:

           from     : starting position
           to       : ending position (position of the arrow head)
           rto      : ending position relative to the starting position
           linetype : line type
           width    : line width
           color    : color

       rectangle

       Draw arbitrary rectangle. e.g.,

           $chart->rectangle(
               from => "screen 0.2, screen 0.2",
               to   => "screen 0.4, screen 0.4",
               fill => {
                   density => 0.2,
                   color   => "#11ff11",
               },
               border    => {color => "blue"},
               linewidth => 3,
               layer     => 'front',
               index     => 1,
           );

       Most properties of a rectangle can be classified into location, dimension, filling and
       border. Location and dimension of the rectangle can be specified by "from" and "to", or
       "from" and "rto", or "at", "width" and "height".  Filling can be specified by "color" and
       "density", or "pattern". Border has only one property "color" so far. Besides, "linewidth"
       controls the line width of the border as well as the filling pattern. The layer that the
       rectangle is drawn is set by "layer". The "index" is a tag of the rectangle, which usually
       can be omitted.

       ellipse

       Draw arbitrary ellipse. e.g.,

           $chart->ellipse(
               at     => "screen 0.2, screen 0.2",
               width  => 0.2,
               height => 0.5
               fill   => {pattern => 2},
               border => {color => "blue"},
           );

       The properties of "ellipse" is the same as those of rectangle, except that its location
       and dimension must be set by "at", "width" and "height".

       circle

       Draw arbitrary circle. e.g.,

           $chart->circle(
               at    => "screen 0.2, screen 0.2",
               size  => 0.5
               fill  => {pattern => 2},
               layer => 'behind',
           );

       The properties of "circle" is the same as those of rectangle, except that its location and
       dimension must be set by "at", "width" and "height".

       polygon

       Draw arbitrary polygon. e.g.,

           $chart->polygon(
               vertices => [
                   " 0,  0.2",
                   "-2, -0.2",
                   {to  => "2, -0.3"},
                   {rto => "0, 0.3"},
               ],
               fill   => {pattern => 2},
               border => {color => "blue"},
           );

       The location and dimension of the polygon are specified by an array of "vertices". Except
       "border", "pattern" of "fill", "index" and "layer", other properties of rectangle is not
       supported.

       copy

       Copy the chart object. This method is especially useful when you want to copy a chart with
       highly customized format. E.g.

           my $chart = Chart::Gnuplot->new(
               ...
           );

           # $copy is a copy of $chart
           my $copy = $chart->copy;

       You may also make multiple copies . E.g.

           my @copies = $chart->copy(10);  # make 10 copies

       convert

       Convert the image format by ImageMagick, e.g.

           $chart->convert('png');

       png

           $chart->png;

       Change the image format to PNG.

       gif

           $chart->gif;

       Change the image format to GIF.

       jpg

           $chart->jpg;

       Change the image format to JPEG.

       ps

           $chart->ps;

       Change the image format to postscript.

       pdf

           $chart->pdf

       Change the image format to PDF.

       command

           $chart->command($gnuplotCommand);

       Add a gnuplot command. This method is useful for the Gnuplot features that have not yet
       implemented.

           $chart->command(\@gnuplotCommands);

       Add a list of gnuplot commands.

       execute

       Execute Gnuplot. Normally users do not need to call this method directly because this
       method would be called automatically by other methods such as plot2d, multiplot and
       animate.

DATASET OBJECT

       The dataset object can be initiated by the "new" method. Properties of the dataset may be
       specified optionally when the object is initiated:

           my $dataset = Chart::Gnuplot::DataSet->new(%options);

       The data source of the dataset can be specified by either one of the following ways:

       1. Arrays of x values, y values and z values (in 3D plots) of the data points.
       2. Array of data points. Each point is specified as an array of x, y, z coordinates
       3. Data file.
       4. Mathematical expression (for a function).

   Dataset Options
       xdata, ydata, zdata

       The x, y, z values of the data points. E.g.

           xdata => \@x

       If "xdata" is omitted but "ydata" is defined, the integer index starting from 0 would be
       used for "xdata".

       points

       Data point matrix of the format [[x1,y1], [x2,y2], [x3,y3], ...]

           points => \@points

       datafile

       Input data file

           datafile => $file

       The data files are assumed to be space-separated, with each row corresponding to one data
       point. Lines beginning with "#" are considered as comments and would be ignored. Other
       formats are not supported at this moment.

       func

       Mathematical function to be plotted. E.g.

           func => "sin(x)*x**3"

       Supported functions:

           abs(x)       : absolute value
           acos(x)      : inverse cosine
           acosh(x)     : inverse hyperbolic cosine
           arg(x)       : complex argument
           asin(x)      : inverse sine
           asinh(x)     : inverse hyperbolic sine
           atan(x)      : inverse tangent
           atanh(x)     : inverse hyperbolic tangent
           besj0(x)     : zeroth order Bessel function of the first kind
           besj1(x)     : first order Bessel function of the first kind
           besy0(x)     : zeroth order Bessel function of the second kind
           besy1(x)     : first order Bessel function of the second kind
           ceil(x)      : ceiling function
           cos(x)       : cosine
           cosh(x)      : hyperbolic cosine
           erf(x)       : error function
           erfc(x)      : complementary error function
           exp(x)       : expontial function
           floor(x)     : floor function
           gamma(x)     : gamma function
           ibeta(a,b,x) : incomplete beta function
           inverf(x)    : inverse error function
           igamma(a,x)  : incomplete gamma function
           imag(x)      : imaginary part
           invnorm(x)   : inverse normal distribution function
           int(x)       : integer part
           lambertw(x)  : Lambert W function
           lgamma(x)    : log gamma function
           log(x)       : natural logarithm
           log10(x)     : common logarithm
           norm(x)      : normal distribution function
           rand(x)      : pseudo random number
           real(x)      : real part
           sgn(x)       : sign function
           sin(x)       : sine
           sinh(x)      : hyperbolic sine
           sqrt(x)      : square root
           tan(x)       : tangent
           tanh(x)      : hyperbolic tangent

       Please see the Gnuplot manual for updated information.

       Supported mathematical constants:

           pi : the circular constant 3.14159...

       Supported arithmetic operators:

           addition           : +
           division           : /
           exponentiation     : **
           factorial          : !
           modulo             : %
           multiplication     : *
           subtraction        : -, e.g., 1-2
           unary minus        : -, e.g., -1

       Supported logical operations:

           and                      : &&
           complement               : ~
           equality                 : ==
           greater than             : >
           greater than or equal to : >=
           inequality               : !=
           less than                : <
           less than or equal to    : <=
           negation                 : !
           or                       : ||
           if ... than else ...     : ?:, e.g., a ? b : c

       Parametric functions may be represented as hash. E.g.

           func => {x => 'sin(t)', y => 'cos(t)'}

       will draw a circle.

       title

       Title of the dataset (shown in the legend).

       style

       The plotting style for the dataset, including

           lines          : join adjacent points by straight lines
           points         : mark each points by a symbol
           linespoints    : both "lines" and "points"
           dots           : dot each points. Useful for large datasets
           impluses       : draw a vertical line from the x-axis to each point
           steps          : join adjacent points by steps
           boxes          : draw a centered box from the x-axis to each point
           xerrorbars     : "dots" with horizontal error bars
           yerrorbars     : "dots" with vertical error bars
           xyerrorbars    : both "xerrorbars" and "yerrorbars"
           xerrorlines    : "linespoints" with horizontal error bars
           yerrorlines    : "linespoints" with vertical error bars
           xyerrorlines   : both "xerrorlines" and "yerrorlines"
           boxerrorbars   : "boxes" with "yerrorbars"
           boxxyerrorbars : use rectangles to represent the data with errors
           financebars    : finance bars for open, high, low and close price
           candlesticks   : candle sticks for open, high, low and close price
           hbars          : horizontal bars (experimental)
           hlines         : horizontal lines (experimental)
           vectors        : arrows
           circles        : circles, for say, bubble charts
           histograms     : for plotting histograms

       "hbars" and "hlines" are available only if the data is input from "points" or "(x,y)data".

       color

       Color of the dataset in the plot. Can be a named color or RBG (#RRGGBB) value.  The
       supported color names can be found in the file doc/colors.txt in the distribution. E.g.

           color => "#99ccff"

       is equivalent to

           color => "dark-red"

       width

       Line width used in the plot. The default width is 1.

       linetype

       Line type. Can be an integer or line type name. The supported line type names can be found
       in the file doc/linetypes.txt in the distribution. E.g.

           linetype => 3

       is equivalent to

           linetype => 'dash'

       Note: the line type may not be displayed as the name if "terminal" is set and is not
       postscript.

       pointtype

       Point type. Can be an integer or point type name. The supported point type names can be
       found in the file doc/pointtypes.txt in the distribution. E.g.

           pointtype => 64

       is equivalent to

           pointtype => 'square'

       Note: the point type may not be displayed as the name if "terminal" is set and is not
       postscript.

       pointsize

       Point size of the plot. E.g.

           pointsize => 3

       The default point size is 1.

       fill

       Filling the boxes. Has effect only on plotting styles with boxes, such as "boxes",
       "boxxyerrorbars" and "financebars". To fill with pattern,

           fill => {
               pattern => 1,
           }

       "pattern" may be an interger from 0 (no filling) to 7.

       To fill with solid,

           fill => {
               color   => '#33bb33',
               density => 0.2,
           }

       "color" may be named color or RGB (#RRGGBB). "density" may be a real number from 0 (empty)
       to 1.

       border

       Border of the boxes. Has effect only on plotting styles with boxes and if "fill" is set.
       "color" (either named color or RGB) is the only supported property. E.g.

           border => {
               color => 'blue',
           }

       axes

       Axes used in the plot. Possible values are "x1y1", "x1y2", "x2y1" and "x2y2".

       timefmt

       Time format of the input data. The valid format are:

           %d : day of the month, 1-31
           %m : month of the year, 1-12
           %y : year, 2-digit, 0-99
           %Y : year, 4-digit
           %j : day of the year, 1-365
           %H : hour, 0-24
           %M : minute, 0-60
           %s : seconds since the Unix epoch (1970-01-01 00:00 UTC)
           %S : second, 0-60
           %b : name of the month, 3-character abbreviation
           %B : name of the month

       smooth

       The smooth method used in plotting data points. Supported methods include cubic splines
       (csplines), Bezier curve (bezier) and other. Please see Gnuplot manual for details.

       using

       The "using" keyword of Gnuplot.

       every

       The "every" keyword of Gnuplot. Has effect only if the data is input from "datafile".

       index

       The "index" keyword of Gnuplot. Has effect only if the data is input from "datafile".

   Dataset Methods
       new

           my $dataset = Chart::Gnuplot::DataSet->new(%options);

       Constructor of the dataset object. If no option is specified, default values would be
       used. See "Dataset Options" for available options.

       copy

       Copy the dataset object. This method is especially useful when you want to copy a dataset
       with highly customized format. E.g.

           my $dataset = Chart::Gnuplot::DataSet->new(
               ...
           );

           # $copy and $dataset will have the same format and contain the same data
           my $copy = $dataset->copy;

       You may also make multiple copies . E.g.

           my @copies = $dataset->copy(10);  # make 10 copies

EXAMPLES

       Some simple examples are shown below. Many more come with the distribution.

       1. Plot a mathematical expression
               my $chart = Chart::Gnuplot->new(
                   output => "expression.png"
               );

               my $dataSet = Chart::Gnuplot::DataSet->new(
                   func => "sin(x)"
               );

               $chart->plot2d($dataSet);

       2. Plot from two Perl arrays, one for the x-axis data and the other the y-axis.
               my $chart = Chart::Gnuplot->new(
                   output => "arrays.png"
               );

               my $dataSet = Chart::Gnuplot::DataSet->new(
                   xdata => \@x,
                   ydata => \@y,
               );

               $chart->plot2d($dataSet);

       3. Plot x-y pairs
               # Data
               my @xy = (
                   [1.1, -3],
                   [1.2, -2],
                   [3.5,  0],
                   ...
               );

               my $chart = Chart::Gnuplot->new(
                   output => "points.png"
               );

               my $dataSet = Chart::Gnuplot::DataSet->new(
                   points => \@xy
               );

               $chart->plot2d($dataSet);

       4. Plot data from a data file
               my $chart = Chart::Gnuplot->new(
                   output => "file.png"
               );

               my $dataSet = Chart::Gnuplot::DataSet->new(
                   datafile => "in.dat"
               );

               $chart->plot2d($dataSet);

       5. Chart title, axis label and legend
               # Chart object
               my $chart = Chart::Gnuplot->new(
                   output => "trigonometric.gif",
                   title  => "Three basic trigonometric functions",
                   xlabel => "angle in radian",
                   ylabel => "function value"
               );

               # Data set objects
               my $sine = Chart::Gnuplot::DataSet->new(
                   func  => "sin(x)",
                   title => "sine function"
               );
               my $cosine = Chart::Gnuplot::DataSet->new(
                   func  => "cos(x)",
                   title => "cosine function"
               );
               my $tangent = Chart::Gnuplot::DataSet->new(
                   func  => "tan(x)",
                   title => "tangent function"
               );

               $chart->plot2d($sine, $cosine, $tangent);

       6. Title in non-English characters (Thanks to WOLfgang Schricker)
               use Encode;

               my $title = ...   # Title with German umlauts
               $title = decode("utf8", $title);

               Chart::Gnuplot->new(
                   encoding => 'iso-8859-1',
                   title    => $title,
               );

       7. Plot a financial time series
               my $chart = Chart::Gnuplot->new(
                   output   => "dj.ps",
                   title    => "Dow-Jones Index time series",
                   timeaxis => 'x',
                   xtics    => {
                       labelfmt => '%b%y',
                   },
               );

               my $dow = Chart::Gnuplot::DataSet->new(
                   file    => "dj.dat",
                   timefmt => '%Y-%m-%d',      # time format of the input data
                   style   => "candlesticks",
                   grid    => 'on',
               );

               $chart->plot2d($dow);

       8. Plot several graphs on the same image
               my $chart = Chart::Gnuplot->new(
                   output => "multiplot.gif",
               );

               my $left = Chart::Gnuplot->new();
               my $sine = Chart::Gnuplot::DataSet->new(
                   func  => "sin(x)",
               );
               $left->add2d($sine);

               my $center = Chart::Gnuplot->new();
               my $cosine = Chart::Gnuplot::DataSet->new(
                   func  => "cos(x)",
               );
               $center->add2d($cosine);

               my $right = Chart::Gnuplot->new();
               my $tangent = Chart::Gnuplot::DataSet->new(
                   func  => "tan(x)",
               );
               $right->add2d($tangent);

               # Place the Chart::Gnuplot objects in matrix to indicate their locations
               $chart->multiplot([
                   [$left, $center, $right]
               ]);

WISH LIST

       1. Improve the manual.
       2. Add curve fitting method.
       3. Improve the testsuite.
       4. Reduce number of temporary files generated.

REQUIREMENTS

       Carp, File::Copy, File::Temp, Storable

       Gnuplot <http://www.gnuplot.info>

       ImageMagick <http://www.imagemagick.org> (for full feature)

SEE ALSO

       Gnuplot official website <http://www.gnuplot.info>

AUTHOR

       Ka-Wai Mak <kwmak@cpan.org>

COPYRIGHT

       Copyright (c) 2008-2011, 2013 Ka-Wai Mak. All rights reserved.

LICENSE

       This library is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.