\input texinfo @c -*-texinfo-*-
@c %**start of header
@setfilename gnuplot.info
@settitle Gnuplot: An Interactive Plotting Program
@setchapternewpage odd
@c %**end of header
@c define the command and options indeces
@defindex cm
@defindex op
@defindex tm
@dircategory Math
@direntry
* GNUPLOT: (gnuplot). An Interactive Plotting Program
@end direntry
@ifnottex
@node Top, gnuplot, (dir), (dir)
@top Master Menu
@end ifnottex
@example
GNUPLOT
An Interactive Plotting Program
Thomas Williams & Colin Kelley
Version 4.3 organized by:
Hans-Bernhard Broeker, Ethan A Merritt, and others
Copyright (C) 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley
Copyright (C) 2004 - 2008 various authors
Mailing list for comments: gnuplot-info@@lists.sourceforge.net
Mailing list for bug reports: gnuplot-bugs@@lists.sourceforge.net
This manual was originally prepared by Dick Crawford
Version 4.3 - 21 May 2008
Major contributors (alphabetic order):
@end example
@c ^
An Interactive Plotting Program
@c ^
Thomas Williams & Colin Kelley
@c ^
Version 4.2 organized by Hans-Bernhard Broeker and others
@c ^
Major contributors (alphabetic order):
@itemize @bullet
@item
Hans-Bernhard Broeker
@item
John Campbell
@item
Robert Cunningham
@item
David Denholm
@item
Gershon Elber
@item
Roger Fearick
@item
Carsten Grammes
@item
Lucas Hart
@item
Lars Hecking
@item
Thomas Koenig
@item
David Kotz
@item
Ed Kubaitis
@item
Russell Lang
@item
Alexander Lehmann
@item
Alexander Mai
@item
Ethan A Merritt
@item
Petr Mikulik
@item
Carsten Steger
@item
Tom Tkacik
@item
Jos Van der Woude
@item
Alex Woo
@item
James R. Van Zandt
@item
Johannes Zellner
@end itemize
@c ^ Copyright (C) 1986 - 1993, 1998 - 2004 Thomas Williams, Colin Kelley
@c ^ Mailing list for comments: gnuplot-info@@lists.sourceforge.net
@c ^ Mailing list for bug reports: gnuplot-bugs@@lists.sourceforge.net
@c ^
@c ^
This manual was prepared by Dick Crawford
@c ^
Last revised: February 2007
@c ^
@menu
* gnuplot::
* plotting_styles::
* Commands::
* Terminal_types::
* Graphical_User_Interfaces::
* Bugs::
* Concept_Index::
* Command_Index::
* Options_Index::
* Function_Index::
* Terminal_Index::
@end menu
@node gnuplot, plotting_styles, Top, Top
@chapter gnuplot
@menu
* Copyright::
* Introduction::
* Seeking-assistance::
* New_features_introduced_in_version_4.3::
* Backwards_compatibility::
* Batch/Interactive_Operation::
* Command-line-editing::
* Comments::
* Coordinates::
* Datastrings::
* Enhanced_text_mode::
* Environment::
* Expressions::
* Glossary::
* linetype::
* mouse_input::
* Plotting::
* Start-up::
* String_constants_and_string_variables::
* Substitution_and_Command_line_macros::
* Syntax::
* Time/Date_data::
@end menu
@node Copyright, Introduction, gnuplot, gnuplot
@section Copyright
@cindex copyright
@cindex license
@example
Copyright (C) 1986 - 1993, 1998, 2004, 2007 Thomas Williams, Colin Kelley
@end example
Permission to use, copy, and distribute this software and its
documentation for any purpose with or without fee is hereby granted,
provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear
in supporting documentation.
Permission to modify the software is granted, but not the right to
distribute the complete modified source code. Modifications are to
be distributed as patches to the released version. Permission to
distribute binaries produced by compiling modified sources is granted,
provided you
@example
1. distribute the corresponding source modifications from the
released version in the form of a patch file along with the binaries,
2. add special version identification to distinguish your version
in addition to the base release version number,
3. provide your name and address as the primary contact for the
support of your modified version, and
4. retain our contact information in regard to use of the base
software.
@end example
Permission to distribute the released version of the source code along
with corresponding source modifications in the form of a patch file is
granted with same provisions 2 through 4 for binary distributions.
This software is provided "as is" without express or implied warranty
to the extent permitted by applicable law.
@example
AUTHORS
@end example
@example
Original Software:
Thomas Williams, Colin Kelley.
@end example
@example
Gnuplot 2.0 additions:
Russell Lang, Dave Kotz, John Campbell.
@end example
@example
Gnuplot 3.0 additions:
Gershon Elber and many others.
@end example
@example
Gnuplot 4.0 additions:
See list of contributors at head of this document.
@end example
@node Introduction, Seeking-assistance, Copyright, gnuplot
@section Introduction
@cindex introduction
@c ?
`gnuplot` is a command-driven interactive function and data plotting program.
syntax:
@example
gnuplot @{X11OPTIONS@} @{OPTIONS@} file1 file2 ...
@end example
Generic X11 options, if any, must come first. See your X11 documentation.
If you are not using X11, ignore this. Options interpreted by gnuplot
may come anywhere on the line. Files are executed in the order specified, as
are commands supplied by the -e option.
Example:
@example
gnuplot file1.in -e "reset" file2.in
@end example
The special filename "-" is used to force reading from stdin. `gnuplot` exits
after the last file is processed. If no load files are named, `gnuplot` takes
interactive input from stdin. See help `batch/interactive` for more details.
The options specific to gnuplot can be listed by typing
@example
gnuplot --help
@end example
`gnuplot` is case sensitive (commands and function names written in lowercase
are not the same as those written in CAPS). All command names may be
abbreviated as long as the abbreviation is not ambiguous. Any number of
commands may appear on a line, separated by semicolons (;). Strings may be
set off by either single or double quotes, although there are some subtle
differences. See `syntax` and `quotes` for more details. Examples:
@example
load "filename"
cd 'dir'
@end example
Many `gnuplot` commands have multiple options. Version 4 is less sensitive
to the order of these options than earlier versions, but some order-dependence
remains. If you see error messages about unrecognized options, please try
again using the exact order listed in the documentation.
Commands may extend over several input lines by ending each line but the last
with a backslash (\). The backslash must be the _last_ character on each
line. The effect is as if the backslash and newline were not there. That
is, no white space is implied, nor is a comment terminated. Therefore,
commenting out a continued line comments out the entire command
(see `comments`). But note that if an error occurs somewhere on a multi-line
command, the parser may not be able to locate precisely where the error is
and in that case will not necessarily point to the correct line.
In this document, curly braces (@{@}) denote optional arguments and a vertical
bar (|) separates mutually exclusive choices. `gnuplot` keywords or @ref{help}
topics are indicated by backquotes or `boldface` (where available). Angle
brackets (<>) are used to mark replaceable tokens. In many cases, a default
value of the token will be taken for optional arguments if the token is
omitted, but these cases are not always denoted with braces around the angle
brackets.
For built-in help on any topic, type @ref{help} followed by the name of the topic
or `help ?` to get a menu of available topics.
The new `gnuplot` user should begin by reading about `plotting` (if in an
interactive session, type `help plotting`).
See the simple.dem demo, also available together with other demos on the web page
@uref{http://www.gnuplot.info/demo/,http://www.gnuplot.info/demo/
}
@node Seeking-assistance, New_features_introduced_in_version_4.3, Introduction, gnuplot
@section Seeking-assistance
@cindex help-desk
@cindex seeking-assistance
@c ^
There is a mailing list for `gnuplot` users. Note, however, that the
newsgroup
@example
comp.graphics.apps.gnuplot
@end example
is identical to the mailing list (they both carry the same set of messages).
We prefer that you read the messages through the newsgroup rather than
subscribing to the mailing list. Instructions for subscribing to gnuplot
mailing lists may be found via the gnuplot development website on SourceForge
@uref{http://sourceforge.net/projects/gnuplot,http://sourceforge.net/projects/gnuplot
}
The address for mailing to list members is:
@example
gnuplot-info@@lists.sourceforge.net
@end example
Bug reports and code contributions should be uploaded to the trackers at
@example
http://sourceforge.net/projects/gnuplot
@end example
The list of those interested in beta-test versions is:
@example
gnuplot-beta@@lists.sourceforge.net
@end example
There is also the canonical (if occasionally out-of-date) gnuplot web page at
@uref{http://www.gnuplot.info,http://www.gnuplot.info
}
Before seeking help, please check the
@uref{http://www.gnuplot.info/faq/,FAQ (Frequently Asked Questions) list.
}
When posting a question, please include full details of the version of
`gnuplot`, the machine, and operating system you are using. A _small_ script
demonstrating the problem may be useful. Function plots are preferable to
datafile plots. If email-ing to gnuplot-info, please state whether or not
you are subscribed to the list, so that users who use news will know to email
a reply to you. There is a form for such postings on the WWW site.
@node New_features_introduced_in_version_4.3, Backwards_compatibility, Seeking-assistance, gnuplot
@section New features introduced in version 4.3
@cindex new-features
Gnuplot version 4.3 offers many new features introduced since the preceding
official version 4.2. This section lists major additions and gives a partial
list of changes and minor new features. For a more exhaustive list, see the
NEWS file.
@menu
* Internationalization::
* Transparency::
* Volatile_Data::
* Canvas_size::
* New_plot_elements::
* New_or_revised_terminal_drivers::
* New_smoothing_algorithms::
@end menu
@node Internationalization, Transparency, New_features_introduced_in_version_4.3, New_features_introduced_in_version_4.3
@subsection Internationalization
Gnuplot 4.3 contains significantly improved support for locale settings and for
UTF-8 character encodings. See @ref{locale}, @ref{encoding}, @ref{decimalsign}.
@node Transparency, Volatile_Data, Internationalization, New_features_introduced_in_version_4.3
@subsection Transparency
Gnuplot now supports transparent objects in several ways. Any object or plot
element that uses a fill style can be assigned a value from fully opaque to
fully transparent. Image or matrix data can be plotted with an alpha channel
using the new plot style @ref{rgbalpha}. See `fillstyle`, @ref{rgbalpha}.
@node Volatile_Data, Canvas_size, Transparency, New_features_introduced_in_version_4.3
@subsection Volatile Data
The new command @ref{refresh} is similar to @ref{replot} except that it uses the
previously-stored input data values rather than rereading the input data file.
Mouse operations (zoom, rotate) will automatically use @ref{refresh} rather than
@ref{replot} if the input data stream is marked `volatile`. Piped or in-line data
is automatically treated as volatile. See @ref{refresh}, `plot datafile volatile`.
@node Canvas_size, New_plot_elements, Volatile_Data, New_features_introduced_in_version_4.3
@subsection Canvas size
@c ?canvas size
@cindex canvas
@c ?set term size
In earlier versions of gnuplot, some terminal types used the values from
@ref{size} to control also the size of the output canvas; others did not.
The use of 'set size' for this purpose was deprecated in version 4.2.
In version 4.3 almost all terminals now behave as follows:
`set term size , ` controls the size of the output
file, or "canvas". Please see individual terminal documentation for allowed
values of the size parameters. By default, the plot will fill this canvas.
`set size , ` scales the plot itself relative to the size of the
canvas. Scale values less than 1 will cause the plot to not fill the entire
canvas. Scale values larger than 1 will cause only a portion of the plot to
fit on the canvas. Please be aware that setting scale values larger than 1
may cause problems on some terminal types.
The major exception to this convention is the PostScript driver, which
by default continues to act as it has in earlier versions. Be warned that
the next version of gnuplot may change the default behaviour of the
PostScript driver as well.
Example:
@example
set size 0.5, 0.5
set term png size 600, 400
set output "figure.png"
plot "data" with lines
@end example
These commands will produce an output file "figure.png" that is 600 pixels
wide and 400 pixels tall. The plot will fill the lower left quarter of this
canvas. This is consistent with the way multiplot mode has always worked,
however it is a change in the way the png driver worked for single plots in
version 4.0.
@node New_plot_elements, New_or_revised_terminal_drivers, Canvas_size, New_features_introduced_in_version_4.3
@subsection New plot elements
@cindex circles
@cindex ellipse
@cindex polygon
The @ref{object} command can now be used to define fixed circles, ellipses, and
polygons as well as rectangles. There is a corresponding new plot style
@ref{circles}. See `circle` @ref{ellipse} @ref{polygon}.
@node New_or_revised_terminal_drivers, New_smoothing_algorithms, New_plot_elements, New_features_introduced_in_version_4.3
@subsection New or revised terminal drivers
Two new drivers based on the cairo and pango libraries are included,
`pngcairo` and `pdfcairo`. These are alternatives to the older libgd-based
png driver and the older PDFLib-based pdf driver. The figures in the pdf
version of this manual were prepared using the pdfcairo terminal driver.
@node New_smoothing_algorithms, , New_or_revised_terminal_drivers, New_features_introduced_in_version_4.3
@subsection New smoothing algorithms
@cindex kdensity
@cindex cumulative
New smoothing algorithms have been added for both 2- and 3-dimensional plots.
`smooth kdensity` and `smooth cumul` can be used with `plot` to draw
smooth histograms and cumulative distribution functions, resp. For use
with `splot` several new smoothing kernels have been added to @ref{dgrid3d}.
See @ref{smooth} @ref{dgrid3d}.
@node Backwards_compatibility, Batch/Interactive_Operation, New_features_introduced_in_version_4.3, gnuplot
@section Backwards compatibility
@c ?backwards compatibility
@cindex compatibility
Gnuplot version 4.0 deprecated certain syntax used in earlier versions, but
continued to recognize it. This is now under the control of a configuration
option, and can be disabled as follows:
@example
./configure --disable-backwards-compatibility
@end example
Notice: Deprecated syntax items may be disabled permanently in some future
version of gnuplot.
One major difference is the introduction of keywords to disambiguate complex
commands, particularly commands containing string variables. A notable issue
was the use of bare numbers to specify offsets, line and point types.
Illustrative examples:
Deprecated:
@example
set title "Old" 0,-1
set data linespoints
plot 1 2 4 # horizontal line at y=1
@end example
New:
@example
TITLE = "New"
set title TITLE offset char 0, char -1
set style data linespoints
plot 1 linetype 2 pointtype 4
@end example
@node Batch/Interactive_Operation, Command-line-editing, Backwards_compatibility, gnuplot
@section Batch/Interactive Operation
@cindex batch/interactive
`gnuplot` may be executed in either batch or interactive modes, and the two
may even be mixed together on many systems.
Any command-line arguments are assumed to be either program options (first
character is -) or names of files containing `gnuplot` commands. The option
-e "command" may be used to force execution of a gnuplot command. Each file
or command string will be executed in the order specified. The special
filename "-" is indicates that commands are to be read from stdin.
`gnuplot` exits after the last file is processed. If no load files and no
command strings are specified, `gnuplot` accepts interactive input from
stdin.
Both the @ref{exit} and @ref{quit} commands terminate the current command file and
`load` the next one, until all have been processed.
Examples:
To launch an interactive session:
@example
gnuplot
@end example
To launch a batch session using two command files "input1" and "input2":
@example
gnuplot input1 input2
@end example
To launch an interactive session after an initialization file "header" and
followed by another command file "trailer":
@example
gnuplot header - trailer
@end example
To give `gnuplot` commands directly in the command line, using the "-persist"
option so that the plot remains on the screen afterwards:
@example
gnuplot -persist -e "set title 'Sine curve'; plot sin(x)"
@end example
To set user-defined variables a and s prior to executing commands from a file:
@example
gnuplot -e "a=2; s='file.png'" input.gpl
@end example
@node Command-line-editing, Comments, Batch/Interactive_Operation, gnuplot
@section Command-line-editing
@cindex line-editing
@cindex editing
@cindex command-line-editing
Command-line editing and command history are supported using either the
external gnu readline library or a built-in equivalent. This choice is a
configuration option at the time gnuplot is built.
The editing commands of the built-in version are given below. The gnu
readline library has its own documentation.
@example
`Line-editing`:
@end example
@example
^B moves back a single character.
^F moves forward a single character.
^A moves to the beginning of the line.
^E moves to the end of the line.
^H and DEL delete the previous character.
^D deletes the current character.
^K deletes from current position to the end of line.
^L,^R redraws line in case it gets trashed.
^U deletes the entire line.
^W deletes from the current word to the end of line.
@end example
@example
`History`:
@end example
@example
^P moves back through history.
^N moves forward through history.
@end example
@node Comments, Coordinates, Command-line-editing, gnuplot
@section Comments
@cindex comments
Comments are supported as follows: a `#` may appear in most places in a line
and `gnuplot` will ignore the rest of the line. It will not have this effect
inside quotes, inside numbers (including complex numbers), inside command
substitutions, etc. In short, it works anywhere it makes sense to work.
See also `set datafile commentschars` for specifying comment characters in
data files. Note that if a comment line ends in '\' then the subsequent
line is also treated as a comment.
@node Coordinates, Datastrings, Comments, gnuplot
@section Coordinates
@cindex coordinates
@cindex axes
The commands @ref{arrow}, `set key`, `set label` and @ref{object} allow you
to draw something at an arbitrary position on the graph. This position is
specified by the syntax:
@example
@{@} , @{@} @{,@{@} @}
@end example
Each can either be `first`, `second`, `graph`, `screen`, or
`character`.
`first` places the x, y, or z coordinate in the system defined by the left
and bottom axes; `second` places it in the system defined by the second axes
(top and right); `graph` specifies the area within the axes---0,0 is bottom
left and 1,1 is top right (for splot, 0,0,0 is bottom left of plotting area;
use negative z to get to the base---see @ref{ticslevel}); `screen`
specifies the screen area (the entire area---not just the portion selected by
@ref{size}), with 0,0 at bottom left and 1,1 at top right; and `character`
gives the position in character widths and heights from the bottom left of
the screen area (screen 0,0), `character` coordinates depend on the chosen
font size.
If the coordinate system for x is not specified, `first` is used. If the
system for y is not specified, the one used for x is adopted.
In some cases, the given coordinate is not an absolute position but a
relative value (e.g., the second position in @ref{arrow} ... `rto`). In
most cases, the given value serves as difference to the first position.
If the given coordinate resides in a logarithmic axis the value is
interpreted as factor. For example,
@example
set logscale x
set arrow 100,5 rto 10,2
@end example
plots an arrow from position 100,5 to position 1000,7 since the x axis is
logarithmic while the y axis is linear.
If one (or more) axis is timeseries, the appropriate coordinate should
be given as a quoted time string according to the @ref{timefmt} format string.
See @ref{xdata} and @ref{timefmt}. `gnuplot` will also accept an integer
expression, which will be interpreted as seconds from 1 January 2000.
@node Datastrings, Enhanced_text_mode, Coordinates, gnuplot
@section Datastrings
@cindex datastrings
Data files may contain string data consisting of either an arbitrary string
of printable characters containing no whitespace or an arbitrary string of
characters, possibly including whitespace, delimited by double quotes.
The following sample line from a datafile is interpreted to contain four
columns, with a text field in column 3:
@example
1.000 2.000 "Third column is all of this text" 4.00
@end example
Text fields can be positioned within a 2-D or 3-D plot using the commands:
@example
plot 'datafile' using 1:2:4 with labels
splot 'datafile using 1:2:3:4 with labels
@end example
A column of text data can also be used to label the ticmarks along one or more
of the plot axes. The example below plots a line through a series of points
with (X,Y) coordinates taken from columns 3 and 4 of the input datafile.
However, rather than generating regularly spaced tics along the x axis
labeled numerically, gnuplot will position a tic mark along the x axis at the
X coordinate of each point and label the tic mark with text taken from column
1 of the input datafile.
@example
set xtics
plot 'datafile' using 3:4:xticlabels(1) with linespoints
@end example
There is also an option that will interpret the first entry in a column of
input data (i.e. the column heading) as a text field, and use it as the key
title for data plotted from that column. The example given below will use the
first entry in column 2 to generate a title in the key box, while processing
the remainder of columns 2 and 4 to draw the required line:
@example
plot 'datafile' using 1:(f($2)/$4) title 2 with lines
@end example
This option must come immediately after the 'using' clause, if any. E.g.:
@example
plot 'datafile' title 2 linetype 5 # OK
plot 'datafile' using 1:2 title 2 linetype 5 # OK
plot 'datafile' using 1:2 linetype 5 title "FOO" # OK
plot 'datafile' using 1:2 linetype 5 title 2 # fails
@end example
See @ref{labels}, `using xticlabels`, @ref{title}, @ref{using}.
@node Enhanced_text_mode, Environment, Datastrings, gnuplot
@section Enhanced text mode
@c ?enhanced text
@cindex enhanced
Many terminal types support an enhanced text mode in which additional
formatting information is embedded in the text string. For example, "x^2"
will write x-squared as we are used to seeing it, with a superscript 2.
This mode is normally selected when you set the terminal, e.g.
"set term png enhanced", but may also be toggled afterward using
"set termoption enhanced", or by marking individual strings as in
"set label 'x_2' noenhanced".
@example
Control Examples Explanation
^ a^x superscript
_ a_x subscript
@@ @@x or a@@^b_@{cd@} phantom box (occupies no width)
& &@{space@} inserts space of specified length
~ ~a@{.8-@} overprints '-' on 'a', raised by .8
times the current fontsize
@end example
Braces can be used to place multiple-character text where a single character
is expected (e.g., 2^@{10@}). To change the font and/or size, use the full form:
@{/[fontname][=fontsize | *fontscale] text@}. Thus @{/Symbol=20 G@} is a 20 pt
GAMMA and @{/*0.75 K@} is a K at three-quarters of whatever fontsize is currently
in effect. (The '/' character MUST be the first character after the '@{'.)
The phantom box is useful for a@@^b_c to align superscripts and subscripts
but does not work well for overwriting an accent on a letter. For the latter,
it is much better to use an encoding (e.g. iso_8859_1 or utf8) that contains
a large variety of letters with accents or other diacritical marks. See
@ref{encoding}. Since the box is non-spacing, it is sensible to put the shorter
of the subscript or superscript in the box (that is, after the @@).
Space equal in length to a string can be inserted using the '&' character.
Thus
@example
'abc&@{def@}ghi'
@end example
would produce
@example
'abc ghi'.
@end example
The '~' character causes the next character or bracketed text to be
overprinted by the following character or bracketed text. The second text
will be horizontally centered on the first. Thus '~a/' will result in an 'a'
with a slash through it. You can also shift the second text vertically by
preceding the second text with a number, which will define the fraction of the
current fontsize by which the text will be raised or lowered. In this case
the number and text must be enclosed in brackets because more than one
character is necessary. If the overprinted text begins with a number, put a
space between the vertical offset and the text ('~@{abc@}@{.5 000@}'); otherwise
no space is needed ('~@{abc@}@{.5---@}'). You can change the font for one or
both strings ('~a@{.5 /*.2 o@}'---an 'a' with a one-fifth-size 'o' on top---and
the space between the number and the slash is necessary), but you can't
change it after the beginning of the string. Neither can you use any other
special syntax within either string. You can, of course, use control
characters by escaping them (see below), such as '~a@{\^@}'
You can access special symbols numerically by specifying \character-code (in
octal), e.g., @{/Symbol \245@} is the symbol for infinity. This does not work
for multibyte encodings like UTF-8, however. In a UTF-8 environment, you
should be able to enter multibyte sequences implicitly by typing or otherwise
selecting the character you want.
You can escape control characters using \, e.g., \\, \@{, and so on.
But be aware that strings in double-quotes are parsed differently than those
enclosed in single-quotes. The major difference is that backslashes may need
to be doubled when in double-quoted strings.
Examples (these are hard to describe in words---try them!):
@example
set xlabel 'Time (10^6 @{/Symbol m@}s)'
set title '@{/Symbol=18 \\362@@_@{/=9.6 0@}^@{/=12 x@}@} \\
@{/Helvetica e^@{-@{/Symbol m@}^2/2@} d@}@{/Symbol m@}'
@end example
The file "ps_guide.ps" in the /docs/psdoc subdirectory of the gnuplot source
distribution contains more examples of the enhanced syntax.
@node Environment, Expressions, Enhanced_text_mode, gnuplot
@section Environment
@cindex environment
A number of shell environment variables are understood by `gnuplot`. None of
these are required, but may be useful.
If GNUTERM is defined, it is used as the name of the terminal type to be
used. This overrides any terminal type sensed by `gnuplot` on start-up, but
is itself overridden by the .gnuplot (or equivalent) start-up file
(see `start-up`) and, of course, by later explicit changes.
GNUHELP may be defined to be the pathname of the HELP file (gnuplot.gih).
On VMS, the logical name GNUPLOT$HELP should be defined as the name of the
help library for `gnuplot`. The `gnuplot` help can be put inside any system
help library, allowing access to help from both within and outside `gnuplot`
if desired.
On Unix, HOME is used as the name of a directory to search for a .gnuplot
file if none is found in the current directory. On AmigaOS,
MS-DOS, Windows and OS/2, GNUPLOT is used. On Windows, the NT-specific
variable USERPROFILE is tried, too. VMS, SYS$LOGIN: is used. Type `help
start-up`.
On Unix, PAGER is used as an output filter for help messages.
On Unix and AmigaOS, SHELL is used for the @ref{shell} command. On
MS-DOS and OS/2, COMSPEC is used for the @ref{shell} command.
FIT_SCRIPT may be used to specify a `gnuplot` command to be executed when a
fit is interrupted---see @ref{fit}. FIT_LOG specifies the default filename of the
logfile maintained by fit.
GNUPLOT_LIB may be used to define additional search directories for data
and command files. The variable may contain a single directory name, or
a list of directories separated by a platform-specific path separator,
eg. ':' on Unix, or ';' on DOS/Windows/OS/2/Amiga platforms. The contents
of GNUPLOT_LIB are appended to the @ref{loadpath} variable, but not saved
with the @ref{save} and `save set` commands.
Several gnuplot terminal drivers access TrueType fonts via the gd library.
For these drivers the font search path is controlled by the environmental
variable GDFONTPATH. Furthermore, a default font for these drivers may be
set via the environmental variable GNUPLOT_DEFAULT_GDFONT.
The postscript terminal uses its own font search path. It is controlled by
the environmental variable GNUPLOT_FONTPATH. The format is the same as for
GNUPLOT_LIB. The contents of GNUPLOT_FONTPATH are appended to the @ref{fontpath}
variable, but not saved with the @ref{save} and `save set` commands.
GNUPLOT_PS_DIR is used by the postscript driver to use external prologue
files. Depending on the build process, gnuplot contains either a builtin
copy of those files or simply a default hardcoded path. Use this variable
to test the postscript terminal with custom prologue files. See
`postscript prologue`.
@node Expressions, Glossary, Environment, gnuplot
@section Expressions
@cindex expressions
In general, any mathematical expression accepted by C, FORTRAN, Pascal, or
BASIC is valid. The precedence of these operators is determined by the
specifications of the C programming language. White space (spaces and tabs)
is ignored inside expressions.
Complex constants are expressed as @{,@}, where and
must be numerical constants. For example, @{3,2@} represents 3 + 2i; @{0,1@}
represents 'i' itself. The curly braces are explicitly required here.
@cindex division
Note that gnuplot uses both "real" and "integer" arithmetic, like FORTRAN and
C. Integers are entered as "1", "-10", etc; reals as "1.0", "-10.0", "1e1",
3.5e-1, etc. The most important difference between the two forms is in
division: division of integers truncates: 5/2 = 2; division of reals does
not: 5.0/2.0 = 2.5. In mixed expressions, integers are "promoted" to reals
before evaluation: 5/2e0 = 2.5. The result of division of a negative integer
by a positive one may vary among compilers. Try a test like "print -5/2" to
determine if your system chooses -2 or -3 as the answer.
The integer expression "1/0" may be used to generate an "undefined" flag,
which causes a point to ignored; the `ternary` operator gives an example.
Or you can use the pre-defined variable NaN to achieve the same result.
@cindex NaN
The real and imaginary parts of complex expressions are always real, whatever
the form in which they are entered: in @{3,2@} the "3" and "2" are reals, not
integers.
Gnuplot can also perform simple operations on strings and string variables.
For example, the expression ("A" . "B" eq "AB") evaluates as true, illustrating
the string concatenation operator and the string equality operator.
A string which contains a numerical value is promoted to the corresponding
integer or real value if used in a numerical expression. Thus ("3" + "4" == 7)
and (6.78 == "6.78") both evaluate to true. An integer, but not a real or
complex value, is promoted to a string if used in string concatenation.
A typical case is the use of integers to construct file names or other strings;
e.g. ("file" . 4 eq "file4") is true.
Substrings can be specified using a postfixed range descriptor [beg:end].
For example, "ABCDEF"[3:4] == "CD" and "ABCDEF"[4:*] == "DEF"
The syntax "string"[beg:end] is exactly equivalent to calling the built-in
string-valued function substr("string",beg,end), except that you cannot
omit either beg or end from the function call.
@menu
* Functions::
* Operators::
* Gnuplot-defined_variables::
* User-defined_variables_and_functions::
@end menu
@node Functions, Operators, Expressions, Expressions
@subsection Functions
@c ?expressions functions
@cindex functions
@opindex functions
The functions in `gnuplot` are the same as the corresponding functions in
the Unix math library, except that all functions accept integer, real, and
complex arguments, unless otherwise noted.
For those functions that accept or return angles that may be given in either
degrees or radians (sin(x), cos(x), tan(x), asin(x), acos(x), atan(x),
atan2(x) and arg(z)), the unit may be selected by @ref{angles}, which
defaults to radians.
@menu
* abs::
* acos::
* acosh::
* arg::
* asin::
* asinh::
* atan::
* atan2::
* atanh::
* EllipticK::
* EllipticE::
* EllipticPi::
* besj0::
* besj1::
* besy0::
* besy1::
* ceil::
* cos::
* cosh::
* erf::
* erfc::
* exp::
* floor::
* gamma::
* ibeta::
* inverf::
* igamma::
* imag::
* invnorm::
* int::
* lambertw::
* lgamma::
* log::
* log10::
* norm::
* rand::
* real::
* sgn::
* sin::
* sinh::
* sqrt::
* tan::
* tanh::
* gprintf::
* sprintf::
* strlen::
* strstrt::
* substr::
* strftime::
* strptime::
* system::
* word::
* words::
* column::
* defined::
* exists::
* stringcolumn::
* timecolumn::
* tm_hour::
* tm_mday::
* tm_min::
* tm_mon::
* tm_sec::
* tm_wday::
* tm_yday::
* tm_year::
* valid::
* elliptic_integrals::
* Random_number_generator::
@end menu
@node abs, acos, Functions, Functions
@subsubsection abs
@c ?expressions functions abs
@c ?functions abs
@cindex abs
@findex abs
The `abs(x)` function returns the absolute value of its argument. The
returned value is of the same type as the argument.
For complex arguments, abs(x) is defined as the length of x in the complex
plane [i.e., sqrt(real(x)**2 + imag(x)**2) ].
@node acos, acosh, abs, Functions
@subsubsection acos
@c ?expressions functions acos
@c ?functions acos
@cindex acos
@findex acos
The `acos(x)` function returns the arc cosine (inverse cosine) of its
argument. `acos` returns its argument in radians or degrees, as selected by
@ref{angles}.
@node acosh, arg, acos, Functions
@subsubsection acosh
@c ?expressions functions acosh
@c ?functions acosh
@cindex acosh
@findex acosh
The `acosh(x)` function returns the inverse hyperbolic cosine of its argument
in radians.
@node arg, asin, acosh, Functions
@subsubsection arg
@c ?expressions functions arg
@c ?functions arg
@cindex arg
@findex arg
The `arg(x)` function returns the phase of a complex number in radians or
degrees, as selected by @ref{angles}.
@node asin, asinh, arg, Functions
@subsubsection asin
@c ?expressions functions asin
@c ?functions asin
@cindex asin
@findex asin
The `asin(x)` function returns the arc sin (inverse sin) of its argument.
`asin` returns its argument in radians or degrees, as selected by @ref{angles}.
@node asinh, atan, asin, Functions
@subsubsection asinh
@c ?expressions functions asinh
@c ?functions asinh
@cindex asinh
@findex asinh
The `asinh(x)` function returns the inverse hyperbolic sin of its argument in
radians.
@node atan, atan2, asinh, Functions
@subsubsection atan
@c ?expressions functions atan
@c ?functions atan
@cindex atan
@findex atan
The `atan(x)` function returns the arc tangent (inverse tangent) of its
argument. `atan` returns its argument in radians or degrees, as selected by
@ref{angles}.
@node atan2, atanh, atan, Functions
@subsubsection atan2
@c ?expressions functions atan2
@c ?functions atan2
@cindex atan2
@findex atan2
The `atan2(y,x)` function returns the arc tangent (inverse tangent) of the
ratio of the real parts of its arguments. @ref{atan2} returns its argument in
radians or degrees, as selected by @ref{angles}, in the correct quadrant.
@node atanh, EllipticK, atan2, Functions
@subsubsection atanh
@c ?expressions functions atanh
@c ?functions atanh
@cindex atanh
@findex atanh
The `atanh(x)` function returns the inverse hyperbolic tangent of its
argument in radians.
@node EllipticK, EllipticE, atanh, Functions
@subsubsection EllipticK
See `elliptic integrals`.
@node EllipticE, EllipticPi, EllipticK, Functions
@subsubsection EllipticE
See `elliptic integrals`.
@node EllipticPi, besj0, EllipticE, Functions
@subsubsection EllipticPi
See `elliptic integrals`.
@node besj0, besj1, EllipticPi, Functions
@subsubsection besj0
@c ?expressions functions besj0
@c ?functions besj0
@cindex besj0
@findex besj0
The `besj0(x)` function returns the j0th Bessel function of its argument.
@ref{besj0} expects its argument to be in radians.
@node besj1, besy0, besj0, Functions
@subsubsection besj1
@c ?expressions functions besj1
@c ?functions besj1
@cindex besj1
@findex besj1
The `besj1(x)` function returns the j1st Bessel function of its argument.
@ref{besj1} expects its argument to be in radians.
@node besy0, besy1, besj1, Functions
@subsubsection besy0
@c ?expressions functions besy0
@c ?functions besy0
@cindex besy0
@findex besy0
The `besy0(x)` function returns the y0th Bessel function of its argument.
@ref{besy0} expects its argument to be in radians.
@node besy1, ceil, besy0, Functions
@subsubsection besy1
@c ?expressions functions besy1
@c ?functions besy1
@cindex besy1
@findex besy1
The `besy1(x)` function returns the y1st Bessel function of its argument.
@ref{besy1} expects its argument to be in radians.
@node ceil, cos, besy1, Functions
@subsubsection ceil
@c ?expressions functions ceil
@c ?functions ceil
@cindex ceil
@findex ceil
The `ceil(x)` function returns the smallest integer that is not less than its
argument. For complex numbers, @ref{ceil} returns the smallest integer not less
than the real part of its argument.
@node cos, cosh, ceil, Functions
@subsubsection cos
@c ?expressions functions cos
@c ?functions cos
@cindex cos
@findex cos
The `cos(x)` function returns the cosine of its argument. `cos` accepts its
argument in radians or degrees, as selected by @ref{angles}.
@node cosh, erf, cos, Functions
@subsubsection cosh
@c ?expressions functions cosh
@c ?functions cosh
@cindex cosh
@findex cosh
The `cosh(x)` function returns the hyperbolic cosine of its argument. @ref{cosh}
expects its argument to be in radians.
@node erf, erfc, cosh, Functions
@subsubsection erf
@c ?expressions functions erf
@c ?functions erf
@cindex erf
@findex erf
The `erf(x)` function returns the error function of the real part of its
argument. If the argument is a complex value, the imaginary component is
ignored. See @ref{erfc}, @ref{inverf}, and @ref{norm}.
@node erfc, exp, erf, Functions
@subsubsection erfc
@c ?expressions functions erfc
@c ?functions erfc
@cindex erfc
@findex erfc
The `erfc(x)` function returns 1.0 - the error function of the real part of
its argument. If the argument is a complex value, the imaginary component is
ignored. See `erf`, @ref{inverf}, and @ref{norm}.
@node exp, floor, erfc, Functions
@subsubsection exp
@c ?expressions functions exp
@c ?functions exp
@cindex exp
@findex exp
The `exp(x)` function returns the exponential function of its argument (`e`
raised to the power of its argument). On some implementations (notably
suns), exp(-x) returns undefined for very large x. A user-defined function
like safe(x) = x<-100 ? 0 : exp(x) might prove useful in these cases.
@node floor, gamma, exp, Functions
@subsubsection floor
@c ?expressions functions floor
@c ?functions floor
@cindex floor
@findex floor
The `floor(x)` function returns the largest integer not greater than its
argument. For complex numbers, @ref{floor} returns the largest integer not
greater than the real part of its argument.
@node gamma, ibeta, floor, Functions
@subsubsection gamma
@c ?expressions functions gamma
@c ?functions gamma
@cindex gamma
@findex gamma
The `gamma(x)` function returns the gamma function of the real part of its
argument. For integer n, gamma(n+1) = n!. If the argument is a complex
value, the imaginary component is ignored.
@node ibeta, inverf, gamma, Functions
@subsubsection ibeta
@c ?expressions functions ibeta
@c ?functions ibeta
@cindex ibeta
@findex ibeta
The `ibeta(p,q,x)` function returns the incomplete beta function of the real
parts of its arguments. p, q > 0 and x in [0:1]. If the arguments are
complex, the imaginary components are ignored.
@node inverf, igamma, ibeta, Functions
@subsubsection inverf
@c ?expressions functions inverf
@c ?functions inverf
@cindex inverf
@findex inverf
The `inverf(x)` function returns the inverse error function of the real part
of its argument. See `erf` and @ref{invnorm}.
@node igamma, imag, inverf, Functions
@subsubsection igamma
@c ?expressions functions igamma
@c ?functions igamma
@cindex igamma
@findex igamma
The `igamma(a,x)` function returns the normalized incomplete gamma
function of the real parts of its arguments, where a > 0 and x >= 0.
The standard notation is P(a,x), e.g. Abramowitz and Stegun (6.5.1),
with limiting value of 1 as x approaches infinity. If the arguments
are complex, the imaginary components are ignored.
@node imag, invnorm, igamma, Functions
@subsubsection imag
@c ?expressions functions imag
@c ?functions imag
@cindex imag
@findex imag
The `imag(x)` function returns the imaginary part of its argument as a real
number.
@node invnorm, int, imag, Functions
@subsubsection invnorm
@c ?expressions functions invnorm
@c ?functions invnorm
@cindex invnorm
@findex invnorm
The `invnorm(x)` function returns the inverse cumulative normal (Gaussian)
distribution function of the real part of its argument. See @ref{norm}.
@node int, lambertw, invnorm, Functions
@subsubsection int
@c ?expressions functions int
@c ?functions int
@cindex int
@findex int
The `int(x)` function returns the integer part of its argument, truncated
toward zero.
@node lambertw, lgamma, int, Functions
@subsubsection lambertw
@c ?expressions functions lambertw
@c ?functions lambertw
@cindex lambertw
@findex lambertw
The lambertw function returns the value of the principal branch of
Lambert's W function, which is defined by the equation (W(z)*exp(W(z))=z.
z must be a real number with z >= -exp(-1).
@node lgamma, log, lambertw, Functions
@subsubsection lgamma
@c ?expressions functions lgamma
@c ?functions lgamma
@cindex lgamma
@findex lgamma
The `lgamma(x)` function returns the natural logarithm of the gamma function
of the real part of its argument. If the argument is a complex value, the
imaginary component is ignored.
@node log, log10, lgamma, Functions
@subsubsection log
@c ?expressions functions log
@c ?functions log
@cindex log
@findex log
The `log(x)` function returns the natural logarithm (base `e`) of its
argument. See @ref{log10}.
@node log10, norm, log, Functions
@subsubsection log10
@c ?expressions functions log10
@c ?functions log10
@cindex log10
@findex log10
The `log10(x)` function returns the logarithm (base 10) of its argument.
@node norm, rand, log10, Functions
@subsubsection norm
@c ?expressions functions norm
@c ?functions norm
@cindex norm
@findex norm
The `norm(x)` function returns the cumulative normal (Gaussian) distribution
function of the real part of its argument. See @ref{invnorm}, `erf` and @ref{erfc}.
@node rand, real, norm, Functions
@subsubsection rand
@c ?expressions functions rand
@c ?functions rand
@cindex rand
@findex rand
`rand(0)` returns a pseudo random number in the interval [0:1] generated
@example
from the current value of two internal 32-bit seeds.
@end example
`rand(-1)` resets both seeds to a standard value.
`rand(x)` for x>0 sets both seeds to a value based on the value of x.
`rand(@{x,y@})` for x>0 sets seed1 to x and seed2 to y.
@node real, sgn, rand, Functions
@subsubsection real
@c ?expressions functions real
@c ?functions real
@cindex real
@findex real
The `real(x)` function returns the real part of its argument.
@node sgn, sin, real, Functions
@subsubsection sgn
@c ?expressions functions sgn
@c ?functions sgn
@cindex sgn
@findex sgn
The `sgn(x)` function returns 1 if its argument is positive, -1 if its
argument is negative, and 0 if its argument is 0. If the argument is a
complex value, the imaginary component is ignored.
@node sin, sinh, sgn, Functions
@subsubsection sin
@c ?expressions functions sin
@c ?functions sin
@cindex sin
@findex sin
The `sin(x)` function returns the sine of its argument. `sin` expects its
argument to be in radians or degrees, as selected by @ref{angles}.
@node sinh, sqrt, sin, Functions
@subsubsection sinh
@c ?expressions functions sinh
@c ?functions sinh
@cindex sinh
@findex sinh
The `sinh(x)` function returns the hyperbolic sine of its argument. @ref{sinh}
expects its argument to be in radians.
@node sqrt, tan, sinh, Functions
@subsubsection sqrt
@c ?expressions functions sqrt
@c ?functions sqrt
@cindex sqrt
@findex sqrt
The `sqrt(x)` function returns the square root of its argument.
@node tan, tanh, sqrt, Functions
@subsubsection tan
@c ?expressions functions tan
@c ?functions tan
@cindex tan
@findex tan
The `tan(x)` function returns the tangent of its argument. `tan` expects
its argument to be in radians or degrees, as selected by @ref{angles}.
@node tanh, gprintf, tan, Functions
@subsubsection tanh
@c ?expressions functions tanh
@c ?functions tanh
@cindex tanh
@findex tanh
The `tanh(x)` function returns the hyperbolic tangent of its argument. @ref{tanh}
expects its argument to be in radians.
@node gprintf, sprintf, tanh, Functions
@subsubsection gprintf
@c ?expressions functions gprintf
@c ?functions gprintf
`gprintf("format",x)` applies gnuplot's own format specifiers to the single
variable x and returns the resulting string. If you want standard C-language
format specifiers, you must instead use `sprintf("format",x)`.
See `format specifiers`.
@node sprintf, strlen, gprintf, Functions
@subsubsection sprintf
@c ?expressions functions sprintf
@c ?functions sprintf
@cindex sprintf
@findex sprintf
`sprintf("format",var1,var2,...)` applies standard C-language format specifiers
to multiple arguments and returns the resulting string. If you want to
use gnuplot's own format specifiers, you must instead call `gprintf()`.
For information on sprintf format specifiers, please see standard C-language
documentation or the unix sprintf man page.
@node strlen, strstrt, sprintf, Functions
@subsubsection strlen
@c ?expressions functions strlen
@c ?functions strlen
@cindex strlen
@findex strlen
`strlen("string")` returns the number of characters in the string.
@node strstrt, substr, strlen, Functions
@subsubsection strstrt
@c ?expressions functions strstrt
@c ?functions strstrt
@cindex strstrt
@findex strstrt
`strstrt("string","key")` searches for the character string "key" in "string"
and returns the index to the first character of "key". If "key" is not found,
returns 0. Similar to C library function strstr except that it returns an
index rather than a string pointer. strstrt("hayneedlestack","needle") = 4.
@node substr, strftime, strstrt, Functions
@subsubsection substr
@c ?expressions functions substr
@c ?functions substr
@cindex substr
@findex substr
@cindex substring
`substr("string",beg,end)` returns the substring consisting of characters
beg through end of the original string. This is exactly equivalent to the
expression "string"[beg:end] except that you do not have the option of
omitting beg or end.
@node strftime, strptime, substr, Functions
@subsubsection strftime
@c ?expressions functions strftime
@c ?functions strftime
@cindex strftime
@findex strftime
`strftime("timeformat",t)` applies the timeformat specifiers to the time t
given in seconds since the year 2000.
See `time_specifiers` and @ref{strptime}.
@node strptime, system, strftime, Functions
@subsubsection strptime
@c ?expressions functions strptime
@c ?functions strptime
@cindex strptime
@findex strptime
`strptime("timeformat",s)` reads the time from the string s using the
timeformat specifiers and converts it into seconds since the year 2000.
See `time_specifiers` and @ref{strftime}.
@node system, word, strptime, Functions
@subsubsection system
@c ?expressions functions system
@c ?functions system
@cindex system
@cmindex system
`system("command")` executes "command" using the standard shell and returns
the resulting character stream from stdout as string variable.
One optional trailing newline is ignored.
This can be used to import external functions into gnuplot scripts using
'f(x) = real(system(sprintf("somecommand %f", x)))'.
@node word, words, system, Functions
@subsubsection word
@c ?expressions functions word
@c ?functions word
@cindex word
@findex word
@cindex word
@findex word
`word("string",n)` returns the nth word in string. For example,
`word("one two three",2)` returns the string "two".
@node words, column, word, Functions
@subsubsection words
@c ?expressions functions words
@c ?functions words
@cindex words
@findex words
@cindex words
@findex words
`words("string")` returns the number of words in string. For example,
`words(" a b c d")` returns the 4.
@node column, defined, words, Functions
@subsubsection column
@c ?expressions functions column
@c ?functions column
@cindex column
@findex column
`column(x)` may be used only in expressions as part of @ref{using} manipulations
to fits or datafile plots. It evaluates to the numerical value of the contents
of column x. See @ref{using}.
@node defined, exists, column, Functions
@subsubsection defined
@c ?expressions functions defined
@c ?functions defined
@cindex defined
@findex defined
`defined(X)` [DEPRECATED] returns 1 if a variable named X has been defined, otherwise
it returns 0.
@node exists, stringcolumn, defined, Functions
@subsubsection exists
@c ?expressions functions exists
@c ?functions exists
@cindex exists
@findex exists
The argument to exists() is a string constant or a string variable;
if the string contains the name of a defined variable, the function returns 1.
Otherwise the function returns 0.
@node stringcolumn, timecolumn, exists, Functions
@subsubsection stringcolumn
@c ?expressions functions stringcolumn
@c ?functions stringcolumn
@cindex stringcolumn
@findex stringcolumn
@c ?expressions functions strcol
@c ?functions strcol
@cindex strcol
`stringcolumn(x)` may be used only in expressions as part of @ref{using} manipulations
to fits or datafile plots. It returns the content of column x as a string variable.
See @ref{using}.
@node timecolumn, tm_hour, stringcolumn, Functions
@subsubsection timecolumn
@c ?expressions functions timecolumn
@c ?functions timecolumn
@cindex timecolumn
@findex timecolumn
`timecolumn(x)` may be used only in expressions as part of @ref{using}
manipulations to fits or datafile plots. See @ref{using}.
It reads the data starting at that column as a time/date value and
returns its value in gnuplot's internal time representation of
"seconds since the millennium".
To find the right @ref{timefmt} string to use, @ref{timecolumn} searches for a
@ref{using} specification with the same column number as its argument.
If one is found, @ref{timefmt} pattern of the target axis for this specifier
is used. Otherwise, @ref{timecolumn} chooses the x axis @ref{timefmt} per default.
@node tm_hour, tm_mday, timecolumn, Functions
@subsubsection tm_hour
@c ?expressions tm_hour
@findex tm_hour
@c ?functions tm_hour
@cindex tm_hour
@findex tm_hour
The @ref{tm_hour} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the hour (an integer in the range 0--23) as a real.
@node tm_mday, tm_min, tm_hour, Functions
@subsubsection tm_mday
@c ?expressions tm_mday
@findex tm_mday
@c ?functions tm_mday
@cindex tm_mday
@findex tm_mday
The @ref{tm_mday} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the day of the month (an integer in the range 1--31)
as a real.
@node tm_min, tm_mon, tm_mday, Functions
@subsubsection tm_min
@c ?expressions tm_min
@findex tm_min
@c ?functions tm_min
@cindex tm_min
@findex tm_min
The @ref{tm_min} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the minute (an integer in the range 0--59) as a real.
@node tm_mon, tm_sec, tm_min, Functions
@subsubsection tm_mon
@c ?expressions tm_mon
@findex tm_mon
@c ?functions tm_mon
@cindex tm_mon
@findex tm_mon
The @ref{tm_mon} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the month (an integer in the range 0--11) as a real.
@node tm_sec, tm_wday, tm_mon, Functions
@subsubsection tm_sec
@c ?expressions tm_sec
@findex tm_sec
@c ?functions tm_sec
@cindex tm_sec
@findex tm_sec
The @ref{tm_sec} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the second (an integer in the range 0--59) as a real.
@node tm_wday, tm_yday, tm_sec, Functions
@subsubsection tm_wday
@c ?expressions tm_wday
@findex tm_wday
@c ?functions tm_wday
@cindex tm_wday
@findex tm_wday
The @ref{tm_wday} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the day of the week (an integer in the range 0--6) as
a real.
@node tm_yday, tm_year, tm_wday, Functions
@subsubsection tm_yday
@c ?expressions tm_yday
@findex tm_yday
@c ?functions tm_yday
@cindex tm_yday
@findex tm_yday
The @ref{tm_yday} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the day of the year (an integer in the range 1--366)
as a real.
@node tm_year, valid, tm_yday, Functions
@subsubsection tm_year
@c ?expressions tm_year
@findex tm_year
@c ?functions tm_year
@cindex tm_year
@findex tm_year
The @ref{tm_year} function interprets its argument as a time, in seconds from
1 Jan 2000. It returns the year (an integer) as a real.
@node valid, elliptic_integrals, tm_year, Functions
@subsubsection valid
@c ?expressions functions valid
@c ?functions valid
@cindex valid
@findex valid
`valid(x)` may be used only in expressions as part of @ref{using} manipulations
to fits or datafile plots. See @ref{using}.
@node elliptic_integrals, Random_number_generator, valid, Functions
@subsubsection elliptic integrals
@c ?expressions functions elliptic integrals
@c ?functions elliptic integrals
@c ?elliptic integrals
@cindex elliptic integrals
@findex elliptic integrals
The `EllipticK(k)` function returns the complete elliptic integral of the first
kind, i.e. the definite integral between 0 and pi/2 of the function
`(1-(k*sin(p))**2)**(-0.5)`. The domain of `k` is -1 to 1 (exclusive).
The `EllipticE(k)` function returns the complete elliptic integral of the
second kind, i.e. the definite integral between 0 and pi/2 of the function
`(1-(k*sin(p))**2)**0.5`. The domain of `k` is -1 to 1 (inclusive).
The `EllipticPi(n,k)` function returns the complete elliptic integral of the
third kind, i.e. the definite integral between 0 and pi/2 of the function
`(1-(k*sin(p))**2)**(-0.5)/(1-n*sin(p)**2)`. The parameter `n` must be less
than 1, while `k` must lie between -1 and 1 (exclusive). Note that by
definition EllipticPi(0,k) == EllipticK(k) for all possible values of `k`.
@node Random_number_generator, , elliptic_integrals, Functions
@subsubsection Random number generator
@c ?expressions random
@c ?functions random
@cindex random
Some older versions of gnuplot used rand(x>0) to produce sequential
pseudo-random numbers. The current behavior is as follows:
@example
`rand(0)` returns a pseudo random number in the interval [0:1] generated
from the current value of two internal 32-bit seeds.
`rand(-1)` resets both seeds to a standard value.
`rand(x)` for x>0 sets both seeds to a value based on the value of x.
`rand(@{x,y@})` for x>0 sets seed1 to x and seed2 to y.
@end example
@node Operators, Gnuplot-defined_variables, Functions, Expressions
@subsection Operators
@c ?expressions operators
@cindex operators
The operators in `gnuplot` are the same as the corresponding operators in the
C programming language, except that all operators accept integer, real, and
complex arguments, unless otherwise noted. The ** operator (exponentiation)
is supported, as in FORTRAN.
Parentheses may be used to change order of evaluation.
@menu
* Unary::
* Binary::
* Ternary::
@end menu
@node Unary, Binary, Operators, Operators
@subsubsection Unary
@c ?expressions operators unary
@c ?operators unary
@cindex unary
The following is a list of all the unary operators and their usages:
@example
Symbol Example Explanation
- -a unary minus
+ +a unary plus (no-operation)
~ ~a * one's complement
! !a * logical negation
! a! * factorial
$ $3 * call arg/column during @ref{using} manipulation
@end example
@cindex factorial
@cindex negation
@cindex one's complement
@cindex operator precedence
(*) Starred explanations indicate that the operator requires an integer
argument.
Operator precedence is the same as in Fortran and C. As in those languages,
parentheses may be used to change the order of operation. Thus -2**2 = -4,
but (-2)**2 = 4.
The factorial operator returns a real number to allow a greater range.
@node Binary, Ternary, Unary, Operators
@subsubsection Binary
@c ?expressions operators binary
@c ?operators binary
The following is a list of all the binary operators and their usages:
@example
Symbol Example Explanation
** a**b exponentiation
* a*b multiplication
/ a/b division
% a%b * modulo
+ a+b addition
- a-b subtraction
== a==b equality
!= a!=b inequality
< a a>b greater than
>= a>=b greater than or equal to
& a&b * bitwise AND
^ a^b * bitwise exclusive OR
| a|b * bitwise inclusive OR
&& a&&b * logical AND
|| a||b * logical OR
= a = b assignment
, (a,b) serial evaluation
. A.B string concatenation
eq A eq B string equality
ne A ne B string inequality
@end example
@cindex bitwise operators
@cindex string operators
@cindex modulo
@cindex exponentiation
(*) Starred explanations indicate that the operator requires integer
arguments.
Capital letters A and B indicate that the operator requires string arguments.
Logical AND (&&) and OR (||) short-circuit the way they do in C. That is,
the second `&&` operand is not evaluated if the first is false; the second
`||` operand is not evaluated if the first is true.
Serial evaluation occurs only in parentheses and is guaranteed to proceed
in left to right order. The value of the rightmost subexpression is returned.
@node Ternary, , Binary, Operators
@subsubsection Ternary
@c ?expressions operators ternary
@c ?operators ternary
@cindex ternary
There is a single ternary operator:
@example
Symbol Example Explanation
?: a?b:c ternary operation
@end example
The ternary operator behaves as it does in C. The first argument (a), which
must be an integer, is evaluated. If it is true (non-zero), the second
argument (b) is evaluated and returned; otherwise the third argument (c) is
evaluated and returned.
The ternary operator is very useful both in constructing piecewise functions
and in plotting points only when certain conditions are met.
Examples:
Plot a function that is to equal sin(x) for 0 <= x < 1, 1/x for 1 <= x < 2,
and undefined elsewhere:
@example
f(x) = 0<=x && x<1 ? sin(x) : 1<=x && x<2 ? 1/x : 1/0
plot f(x)
@end example
@c ^
Note that `gnuplot` quietly ignores undefined values, so the final branch of
the function (1/0) will produce no plottable points. Note also that f(x)
will be plotted as a continuous function across the discontinuity if a line
style is used. To plot it discontinuously, create separate functions for the
two pieces. (Parametric functions are also useful for this purpose.)
For data in a file, plot the average of the data in columns 2 and 3 against
the datum in column 1, but only if the datum in column 4 is non-negative:
@example
plot 'file' using 1:( $4<0 ? 1/0 : ($2+$3)/2 )
@end example
For an explanation of the @ref{using} syntax, please see @ref{using}.
@node Gnuplot-defined_variables, User-defined_variables_and_functions, Operators, Expressions
@subsection Gnuplot-defined variables
@c ?gnuplot-defined variables
Gnuplot maintains a number of read-only variables that reflect the current
internal state of the program and the most recent plot. These variables begin
with the prefix "GPVAL_".
Examples include GPVAL_TERM, GPVAL_X_MIN, GPVAL_X_MAX, GPVAL_Y_MIN.
Type `show variables all` to display the complete list and current values.
Values related to axes parameters (ranges, log base) are values used during the
last plot, not those currently `set`.
@cindex errors
@cindex error state
The read-only variable GPVAL_ERRNO is set to a non-zero value if any gnuplot
command terminates early due to an error. The most recent error message is
stored in the string variable GPVAL_ERRMSG. Both GPVAL_ERRNO and GPVAL_ERRMSG
can be cleared using the command `reset errors`.
Interactive terminals with `mouse` functionality maintain read-only variables
with the prefix "MOUSE_". See @ref{variables} for details.
The @ref{fit} mechanism uses several variables with names that begin "FIT_". It
is safest to avoid using such names. "FIT_LIMIT", however, is one that you
may wish to redefine. Under `set fit errorvariables`, the error for each
fitted parameter will be stored in a variable named like the parameter, but
with "_err" appended. See the documentation on @ref{fit} for details.
See @ref{variables}, `reset errors`, @ref{variables}, and @ref{fit}.
@node User-defined_variables_and_functions, , Gnuplot-defined_variables, Expressions
@subsection User-defined variables and functions
@c ?expressions user-defined
@c ?user-defined variables
@cindex user-defined
@cindex variables
@opindex variables
New user-defined variables and functions of one through five variables may
be declared and used anywhere, including on the `plot` command itself.
User-defined function syntax:
@example
( @{,@} ... @{,@} ) =
@end example
where is defined in terms of through .
User-defined variable syntax:
@example
=
@end example
Examples:
@example
w = 2
q = floor(tan(pi/2 - 0.1))
f(x) = sin(w*x)
sinc(x) = sin(pi*x)/(pi*x)
delta(t) = (t == 0)
ramp(t) = (t > 0) ? t : 0
min(a,b) = (a < b) ? a : b
comb(n,k) = n!/(k!*(n-k)!)
len3d(x,y,z) = sqrt(x*x+y*y+z*z)
plot f(x) = sin(x*a), a = 0.2, f(x), a = 0.4, f(x)
@end example
@example
file = "mydata.inp"
file(n) = sprintf("run_%d.dat",n)
@end example
@c ^
The final two examples illustrate a user-defined string variable and a
user-defined string function.
@cindex NaN
@cindex pi
Note that the variables `pi` (3.14159...) and `NaN` (IEEE "Not a Number") are
already defined. You can redefine these to something else if you really need
to. The original values can be recovered by setting:
@example
NaN = GPVAL_NaN
pi = GPVAL_pi
@end example
Other variables may be defined under various gnuplot operations like mousing in
interactive terminals or fitting; see @ref{variables} for details.
You can check for existence of a given variable V by the exists("V")
expression. For example
@example
a = 10
if (exists("a")) print "a is defined"
if (!exists("b")) print "b is not defined"
@end example
Valid names are the same as in most programming languages: they must begin
with a letter, but subsequent characters may be letters, digits, "$", or "_".
See @ref{functions}, @ref{functions}, @ref{variables}, @ref{macros}.
@node Glossary, linetype, Expressions, gnuplot
@section Glossary
@cindex glossary
Throughout this document an attempt has been made to maintain consistency of
nomenclature. This cannot be wholly successful because as `gnuplot` has
evolved over time, certain command and keyword names have been adopted that
preclude such perfection. This section contains explanations of the way
some of these terms are used.
A "page" or "screen" or "canvas" is the entire area addressable by `gnuplot`.
On a desktop it is a full window; on a plotter, it is a single sheet of paper;
in svga mode it is the full monitor screen.
A screen may contain one or more "plots". A plot is defined by an abscissa
and an ordinate, although these need not actually appear on it, as well as
the margins and any text written therein.
A plot contains one "graph". A graph is defined by an abscissa and an
ordinate, although these need not actually appear on it.
A graph may contain one or more "lines". A line is a single function or
data set. "Line" is also a plotting style. The word will also be used in
sense "a line of text". Presumably the context will remove any ambiguity.
The lines on a graph may have individual names. These may be listed
together with a sample of the plotting style used to represent them in
the "key", sometimes also called the "legend".
The word "title" occurs with multiple meanings in `gnuplot`. In this
document, it will always be preceded by the adjective "plot", "line", or
"key" to differentiate among them.
A 2D graph may have up to four labelled @ref{axes}. The names of the four axes
are "x" for the axis along the bottom border of the plot, "y" for the axis
along the left border, "x2" for the top border, and "y2" for the right border.
See @ref{axes}.
A 3D graph may have up to three labelled @ref{axes} -- "x", "y" and "z". It is
not possible to say where on the graph any particular axis will fall because
you can change the direction from which the graph is seen with @ref{view}.
When discussing data files, the term "record" will be resurrected and used
to denote a single line of text in the file, that is, the characters between
newline or end-of-record characters. A "point" is the datum extracted from
a single record. A "datablock" is a set of points from consecutive records,
delimited by blank records. A line, when referred to in the context of a
data file, is a subset of a datablock.
@node linetype, mouse_input, Glossary, gnuplot
@section linetype, colors, and styles
@cindex linetype
@cindex colors
Each gnuplot terminal type provides a set of distinct "linetypes". These may
differ in color, in thickness, in dot/dash pattern, or in some combination of
color and dot/dash. The default linetypes for a particular terminal can be
previewed by issuing the @ref{test} command after setting the terminal type.
The pre-defined colors and dot/dash patterns are not guaranteed to be
consistent for all terminal types, but all terminals use the special linetype
-1 to mean a solid line in the primary foreground color (normally black).
By default, successive functions or datafiles plotted by a single command will
be assigned successive linetypes. You can override this default by specifying
a particular linetype for any function, datafile, or plot element.
Examples:
@example
plot "foo", "bar" # plot two files using linetypes 1, 2
plot sin(x) linetype 4 # terminal-specific linetype color 4
plot sin(x) lt -1 # black
@end example
@cindex colors
For many terminal types it is also possible to assign user-defined colors
using explicit rgb (red, green, blue) values, named colors, or color values
that refer to the current PM3D palette.
Examples:
@example
plot sin(x) lt rgb "violet" # one of gnuplot's named colors
plot sin(x) lt rgb "#FF00FF" # explicit RGB triple in hexadecimal
plot sin(x) lt palette cb -45 # whatever color corresponds to -45
# in the current cbrange of the palette
plot sin(x) lt palette frac 0.3 # fractional value along the palette
@end example
See @ref{colornames}, @ref{palette}, @ref{cbrange}.
For terminals that support dot/dash patterns, each default linetype has both
a dot-dash pattern and a default color. However, you can override the default
color by using the keyword `linecolor`, abbreviated `lc`. For example, the
postscript terminal provides a dashed blue line as linetype 3. The plot
commands below use this same dash pattern for three plots, one in blue (the
default), another in red (the default for linetype 1), and a third in gold.
Example:
@example
set term postscript dashed color
plot 'foo' lt 3, 'baz' lt 3 linecolor 1, 'bar' lt 3 lc rgb 'gold'
@end example
Lines can have additional properties such as linewidth. You can associate
these various properties, as well as equivalent properties for point symbols,
into user-defined "line styles" using the command `set style line`. Once
you have defined a linestyle, you can use it in a plot command to control
the appearance of one or more plot elements.
Examples:
@example
# define a new line style with terminal-independent color cyan,
# linewidth 3, and associated point type 6 (a circle with a dot in it).
set style line 5 lt rgb "cyan" lw 3 pt 6
plot sin(x) with linespoints ls 5 # user-defined line style 5
@end example
See `linestyle`, `set style line`.
@menu
* colorspec::
@end menu
@node colorspec, , linetype, linetype
@subsection colorspec
@cindex colorspec
@cindex rgbcolor
@cindex colors
@cindex lc
@cindex linecolor
@cindex tc
@cindex textcolor
Many commands allow you to specify a linetype with an explicit color.
Terminal-independent color choice is only possible for terminals that support
RGB color or pm3d palettes.
Syntax:
@example
... @{linecolor | lc@}
... @{textcolor | tc@}
@end example
where has one of the following forms:
@example
rgbcolor "colorname"
rgbcolor "#RRGGBB"
rgbcolor variable # color is read from input file
palette frac # runs from 0 to 1
palette cb # lies within cbrange
palette z
variable # color index is read from input file
@end example
"colorname" refers to one of the color names built in to gnuplot. For a list
of the available names, see @ref{colornames}.
"#RRGGBB" is a hexadecimal constant preceded by the "#" symbol. The RRGGBB
represents the red, green, and blue components of the color, each on a scale
from 0 - 255. For example, magenta = full-scale red + full-scale blue would
be represented by #FF00FF, which is the hexadecimal representation of
(255 << 16) + (0 << 8) + (255).
The color palette is a linear gradient of colors that smoothly maps a
single numerical value onto a particular color. Two such mappings are always
in effect. `palette frac` maps a fractional value between 0 and 1 onto the
full range of the color palette. `palette cb` maps the range of the color
axis onto the same palette. See @ref{cbrange}. See also `set colorbox`.
You can use either of these to select a constant color from the current
palette.
"palette z" maps the z value of each plot segment or plot element into the
cbrange mapping of the palette. This allows smoothly-varying color along a
3d line or surface. It also allows coloring 2D plots by palette values read
from an extra column of data (not all 2D plot styles allow an extra column).
@menu
* rgbcolor_variable::
* linecolor_variable::
@end menu
@node rgbcolor_variable, linecolor_variable, colorspec, colorspec
@subsubsection rgbcolor variable
@c ?rgbcolor variable
@c ?lc rgbcolor variable
@c ?tc rgbcolor variable
Most plot commands assign a single color (linetype) to each element of the
plot. If there are multiple plots on a single graph, the default color
(linetype) is incremented sequentially. You can instead assign a separate
color for each data point, line segment, or label based on additional
information in the input data file. This is indicated by the colorspec
keyword `variable`.
`lc rgbcolor variable` tells the program to use a 24-bit RGB color from a
separate column in the data file. This requires a corresponding additional
column in the @ref{using} specifier. The extra column is interpreted as a 24-bit
packed RGB triple. These are most easily specified as hexidecimal values
(see `rgbcolor`). Text colors are similarly set using `tc rgbcolor variable`.
Example:
@example
# Place colored points in 3D at the x,y,z coordinates corresponding to
# their red, green, and blue components
rgb(r,g,b) = 65536 * int(r) + 256 * int(g) + int(b)
splot "data" using 1:2:3:(rgb($1,$2,$3)) with points lc rgb variable
@end example
@node linecolor_variable, , rgbcolor_variable, colorspec
@subsubsection linecolor variable
@c ?linecolor variable
@c ?lc variable
@c ?textcolor variable
@c ?tc variable
Most plot commands assign a single color (linetype) to each element of the
plot. If there are multiple plots on a single graph, the default color
(linetype) is incremented sequentially. You can instead assign a separate
color for each data point, line segment, or label based on additional
information in the input data file. This is indicated by the colorspec
keyword `variable`.
`lc variable` tells the program to use the value read from one column of the
input data as a linestyle index, and use the color belonging to that linestyle.
This requires a corresponding additional column in the @ref{using} specifier.
Text colors can be set similarly using `tc variable`.
A single data file may contain multiple sets of data, separated by two blank
lines. Each of these separate sets is assigned an index value (see @ref{index})
that can be retrieved via the using specifier column(-2). See `pseudocolumns`.
All data in the file is drawn with the same color/linestyle/pointtype
properties by default. The command `lc variable` can be used to assign
different colors to each data set in the file by using the index value from
pseudocolumn -2.
Examples:
@example
# Use the third column of data to assign colors to individual points
plot 'data' using 1:2:3 with points lc variable
@end example
@example
# Use the data set index to choose a linestyle color
plot 'data' using 1:2:(column(-2)) with lines lc variable
@end example
@node mouse_input, Plotting, linetype, gnuplot
@section mouse input
@c ?mouse input
The `x11`, `pm`, `windows`, `ggi`, and `wxt` terminals allow interaction with
the current plot using the mouse. They also support the definition of hotkeys
to activate pre-defined functions by hitting a single key while the mouse
focus is in the active plot window. It is even possible to combine mouse
input with `batch` command scripts, by invoking the command `pause mouse`
and then using the mouse variables returned by mouse clicking as parameters
for subsequent scripted actions. See `bind` and @ref{variables}.
See also the command `set mouse`.
@menu
* bind::
* Mouse_variables::
@end menu
@node bind, Mouse_variables, mouse_input, mouse_input
@subsection bind
@c ?commands bind
@cindex bind
@opindex bind
Syntax:
@example
bind @{allwindows@} [] [""]
bind ""
reset bind
@end example
The `bind` allows defining or redefining a hotkey, i.e. a sequence of gnuplot
commands which will be executed when a certain key or key sequence is pressed
while the driver's window has the input focus. Note that `bind` is only
available if gnuplot was compiled with `mouse` support and it is used by all
mouse-capable terminals. A user-specified binding supersedes any builtin
bindings, except that and 'q' cannot normally be rebound. For an
exception, see `bind space`.
Mouse buttons cannot be rebound.
You get the list of all hotkeys by typing `show bind` or `bind` or by typing
the hotkey 'h' in the graph window.
Key bindings are restored to their default state by `reset bind`.
Note that multikey-bindings with modifiers must be given in quotes.
Normally hotkeys are only recognized when the currently active plot window
has focus. `bind allwindows ...` (short form: `bind all ...`)
causes the binding for to apply to all gnuplot plot windows, active
or not. In this case gnuplot variable MOUSE_KEY_WINDOW is set to the ID
of the originating window, and may be used by the bound command.
Examples:
- set bindings:
@example
bind a "replot"
bind "ctrl-a" "plot x*x"
bind "ctrl-alt-a" 'print "great"'
bind Home "set view 60,30; replot"
bind all Home 'print "This is window ",MOUSE_KEY_WINDOW'
@end example
- show bindings:
@example
bind "ctrl-a" # shows the binding for ctrl-a
bind # shows all bindings
show bind # show all bindings
@end example
- remove bindings:
@example
bind "ctrl-alt-a" "" # removes binding for ctrl-alt-a
(note that builtins cannot be removed)
reset bind # installs default (builtin) bindings
bind! # deprecated form of "reset bind"
@end example
- bind a key to toggle something:
@example
v=0
bind "ctrl-r" "v=v+1;if(v%2)set term x11 noraise; else set term x11 raise"
@end example
Modifiers (ctrl / alt) are case insensitive, keys not:
@example
ctrl-alt-a == CtRl-alT-a
ctrl-alt-a != ctrl-alt-A
@end example
List of modifiers (alt == meta):
@example
ctrl, alt
@end example
List of supported special keys:
@example
"BackSpace", "Tab", "Linefeed", "Clear", "Return", "Pause", "Scroll_Lock",
"Sys_Req", "Escape", "Delete", "Home", "Left", "Up", "Right", "Down",
"PageUp", "PageDown", "End", "Begin",
@end example
@example
"KP_Space", "KP_Tab", "KP_Enter", "KP_F1", "KP_F2", "KP_F3", "KP_F4",
"KP_Home", "KP_Left", "KP_Up", "KP_Right", "KP_Down", "KP_PageUp",
"KP_PageDown", "KP_End", "KP_Begin", "KP_Insert", "KP_Delete", "KP_Equal",
"KP_Multiply", "KP_Add", "KP_Separator", "KP_Subtract", "KP_Decimal",
"KP_Divide",
@end example
@example
"KP_1" - "KP_9", "F1" - "F12"
@end example
The following are window events rather than actual keys
@example
"Close"
@end example
See also help for `mouse` and @ref{if}.
@menu
* bind_space::
@end menu
@node bind_space, , bind, bind
@subsubsection bind space
@c ?commands bind space
@c ?bind space
If gnuplot was built with configuration option --enable-raise-console, then
typing in the plot window raises gnuplot's command window. This hotkey
can be changed to ctrl-space by starting gnuplot as 'gnuplot -ctrlq', or by
setting the XResource 'gnuplot*ctrlq'. See `x11 command-line-options`.
@node Mouse_variables, , bind, mouse_input
@subsection Mouse variables
@c ?mouse variables
When mousing is active, clicking in the active window will set several user
variables that can be accessed from the gnuplot command line. The coordinates
of the mouse at the time of the click are stored in MOUSE_X MOUSE_Y MOUSE_X2
and MOUSE_Y2. The mouse button clicked, and any meta-keys active at that time,
are stored in MOUSE_BUTTON MOUSE_SHIFT MOUSE_ALT and MOUSE_CTRL. These
variables are set to undefined at the start of every plot, and only become
defined in the event of a mouse click in the active plot window. To determine
from a script if the mouse has been clicked in the active plot window, it is
sufficient to test for any one of these variables being defined.
@example
plot 'something'
pause mouse
if (defined(MOUSE_BUTTON)) call 'something_else'; \
else print "No mouse click."
@end example
It is also possible to track keystrokes in the plot window using the mousing
code.
@example
plot 'something'
pause mouse keypress
print "Keystroke ", MOUSE_KEY, " at ", MOUSE_X, " ", MOUSE_Y
@end example
When `pause mouse keypress` is terminated by a keypress, then MOUSE_KEY will
contain the ascii character value of the key that was pressed. MOUSE_CHAR will
contain the character itself as a string variable. If the pause command is
terminated abnormally (e.g. by ctrl-C or by externally closing the plot window)
then MOUSE_KEY will equal -1.
Note that after a zoom by mouse, you can read the new ranges as GPVAL_X_MIN,
GPVAL_X_MAX, GPVAL_Y_MIN, and GPVAL_Y_MAX, see @ref{variables}.
@node Plotting, Start-up, mouse_input, gnuplot
@section Plotting
@cindex plotting
There are three `gnuplot` commands which actually create a plot: `plot`,
`splot` and @ref{replot}. `plot` generates 2D plots, `splot` generates 3-d
plots (actually 2D projections, of course), and @ref{replot} appends its
arguments to the previous `plot` or `splot` and executes the modified
command.
Much of the general information about plotting can be found in the discussion
of `plot`; information specific to 3D can be found in the `splot` section.
`plot` operates in either rectangular or polar coordinates -- see `set polar`
for details of the latter. `splot` operates only in rectangular coordinates,
but the @ref{mapping} command allows for a few other coordinate systems to be
treated. In addition, the @ref{using} option allows both `plot` and `splot` to
treat almost any coordinate system you'd care to define.
@cindex axes
`plot` also lets you use each of the four borders -- x (bottom), x2 (top), y
(left) and y2 (right) -- as an independent axis. The @ref{axes} option lets you
choose which pair of axes a given function or data set is plotted against. A
full complement of `set` commands exists to give you complete control over
the scales and labelling of each axis. Some commands have the name of an
axis built into their names, such as @ref{xlabel}. Other commands have one
or more axis names as options, such as `set logscale xy`. Commands and
options controlling the z axis have no effect on 2D graphs.
`splot` can plot surfaces and contours in addition to points and/or lines.
In addition to `splot`, see @ref{isosamples} for information about defining
the grid for a 3D function; @ref{datafile} for information about the
requisite file structure for 3D data values; and @ref{contour} and
@ref{cntrparam} for information about contours.
In `splot`, control over the scales and labels of the axes are the same as
with `plot`, except that commands and options controlling the x2 and y2 axes
have no effect whereas of course those controlling the z axis do take effect.
@node Start-up, String_constants_and_string_variables, Plotting, gnuplot
@section Start-up
@cindex startup
@cindex start
@cindex .gnuplot
@c ^
When `gnuplot` is run, it looks for an initialization file to load.
This file is called `.gnuplot` on Unix and AmigaOS systems, and
`GNUPLOT.INI` on other systems. If this file is not found in the
current directory, the program will look for it in the HOME directory
(under AmigaOS, MS-DOS, Windows and OS/2, the
environment variable `GNUPLOT` should contain the name of this
directory; on Windows NT, it will use `USERPROFILE` if GNUPLOT isn't
defined). Note: if NOCWDRC is defined during the installation,
`gnuplot` will not read from the current directory.
If the initialization file is found, `gnuplot` executes the commands in it.
These may be any legal `gnuplot` commands, but typically they are limited to
setting the terminal and defining frequently-used functions or variables.
@node String_constants_and_string_variables, Substitution_and_Command_line_macros, Start-up, gnuplot
@section String constants and string variables
@cindex strings
@c ?string variables
In addition to string constants, most gnuplot commands also accept a string
variable, a string expression, or a function that returns a string.
For example, the following four methods of creating a plot all result in the
same plot title:
@example
four = "4"
graph4 = "Title for plot #4"
graph(n) = sprintf("Title for plot #%d",n)
@end example
@example
plot 'data.4' title "Title for plot #4"
plot 'data.4' title graph4
plot 'data.4' title "Title for plot #".four
plot 'data.4' title graph(4)
@end example
Since integers are promoted to strings when operated on by the string
concatenation operator, the following method also works:
@example
N = 4
plot 'data.'.N title "Title for plot #".N
@end example
In general, elements on the command line will only be evaluated as possible
string variables if they are not otherwise recognizable as part of the normal
gnuplot syntax. So the following sequence of commands is legal, although
probably should be avoided so as not to cause confusion:
@example
plot = "my_datafile.dat"
title = "My Title"
plot plot title title
@end example
There are three binary operators that require string operands: the string
concatenation operator ".", the string equality operator "eq" and the string
inequality operator "ne". The following example will print TRUE.
@example
if ("A"."B" eq "AB") print "TRUE"
@end example
See also the two string formatting functions @ref{gprintf} and @ref{sprintf}.
@cindex substring
Substrings can be specified by appending a range specifier to any string,
string variable, or string-valued function. The range specifier has the
form [begin:end], where begin is the index of the first character of the
substring and end is the index of the last character of the substring.
The first character has index 1. The begin or end fields may be empty, or
contain '*', to indicate the true start or end of the original string.
E.g. str[:] and str[*:*] both describe the full string str.
@node Substitution_and_Command_line_macros, Syntax, String_constants_and_string_variables, gnuplot
@section Substitution and Command line macros
@cindex substitution
When a command line to gnuplot is first read, i.e. before it is interpreted
or executed, two forms of lexical substitution are performed. These are
triggered by the presence of text in backquotes (ascii character 96) or
preceded by @@ (ascii character 64).
@menu
* Substitution_of_system_commands_in_backquotes::
* Substitution_of_string_variables_as_macros::
* String_variables::
@end menu
@node Substitution_of_system_commands_in_backquotes, Substitution_of_string_variables_as_macros, Substitution_and_Command_line_macros, Substitution_and_Command_line_macros
@subsection Substitution of system commands in backquotes
@c ?substitution backquotes
@cindex backquotes
@c ?shell commands
Command-line substitution is specified by a system command enclosed in
backquotes. This command is spawned and the output it produces replaces
the backquoted text on the command line. Some implementations also support
pipes; see @ref{special-filenames}.
Command-line substitution can be used anywhere on the `gnuplot` command
line, except inside strings delimited by single quotes.
Example:
This will run the program `leastsq` and replace `leastsq` (including
backquotes) on the command line with its output:
@example
f(x) = `leastsq`
@end example
or, in VMS
@example
f(x) = `run leastsq`
@end example
These will generate labels with the current time and userid:
@example
set label "generated on `date +%Y-%m-%d` by `whoami`" at 1,1
set timestamp "generated on %Y-%m-%d by `whoami`"
@end example
@node Substitution_of_string_variables_as_macros, String_variables, Substitution_of_system_commands_in_backquotes, Substitution_and_Command_line_macros
@subsection Substitution of string variables as macros
@c ?substitution macros
@cindex macros
@opindex macros
@cindex exists
@findex exists
Substitution of command line macros is disabled by default, but may be
enabled using the @ref{macros} command. If macro substitution is enabled,
the character @@ is used to trigger substitution of the current value of a
string variable into the command line. The text in the string variable may
contain any number of lexical elements. This allows string variables to be
used as command line macros. Only string constants may be expanded using this
mechanism, not string-valued expressions.
For example:
@example
set macros
style1 = "lines lt 4 lw 2"
style2 = "points lt 3 pt 5 ps 2"
range1 = "using 1:3"
range2 = "using 1:5"
plot "foo" @@range1 with @@style1, "bar" @@range2 with @@style2
@end example
The line containing @@ symbols is expanded on input, so that by the time it is
executed the effect is identical to having typed in full
@example
plot "foo" using 1:3 with lines lt 4 lw 2, \
"bar" using 1:5 with points lt 3 pt 5 ps 2
@end example
The function exists() may be useful in connection with macro evaluation.
The following example checks that C can safely be expanded as the name of
a user-defined variable:
@example
C = "pi"
if (exists(C)) print C," = ", @@C
@end example
Macro expansion does not occur inside either single or double quotes.
However macro expansion does occur inside backquotes.
For execution of complete commands the @ref{evaluate} command may also be handy.
@node String_variables, , Substitution_of_string_variables_as_macros, Substitution_and_Command_line_macros
@subsection String variables, macros, and command line substitution
@cindex mixing_macros_backquotes
@c ?substitution mixing_macros_backquotes
The interaction of string variables, backquotes and macro substitution is
somewhat complicated. Backquotes do not block macro substitution, so
@example
filename = "mydata.inp"
lines = ` wc --lines @@filename | sed "s/ .*//" `
@end example
results in the number of lines in mydata.inp being stored in the integer
variable lines. And double quotes do not block backquote substitution, so
@example
mycomputer = "`uname -n`"
@end example
results in the string returned by the system command `uname -n` being stored
in the string variable mycomputer.
However, macro substitution is not performed inside double quotes, so you
cannot define a system command as a macro and then use both macro and backquote
substitution at the same time.
@example
machine_id = "uname -n"
mycomputer = "`@@machine_id`" # doesn't work!!
@end example
This fails because the double quotes prevent @@machine_id from being interpreted
as a macro. To store a system command as a macro and execute it later you must
instead include the backquotes as part of the macro itself. This is
accomplished by defining the macro as shown below. Notice that the sprintf
format nests all three types of quotes.
@example
machine_id = sprintf('"`uname -n`"')
mycomputer = @@machine_id
@end example
@node Syntax, Time/Date_data, Substitution_and_Command_line_macros, gnuplot
@section Syntax
@cindex syntax
@cindex specify
@cindex punctuation
Version 4 of gnuplot is much less sensitive than earlier versions to the
order of keywords and suboptions. However, if you get error messages from
specifying options that you think should work, please try rearranging them
into the exact order listed by the documentation.
Options and any accompanying parameters are separated by spaces whereas lists
and coordinates are separated by commas. Ranges are separated by colons and
enclosed in brackets [], text and file names are enclosed in quotes, and a
few miscellaneous things are enclosed in parentheses. Braces @{@} are used for
a few special purposes.
Commas are used to separate coordinates on the `set` commands @ref{arrow},
`key`, and `label`; the list of variables being fitted (the list after the
`via` keyword on the @ref{fit} command); lists of discrete contours or the loop
parameters which specify them on the @ref{cntrparam} command; the arguments
of the `set` commands @ref{dgrid3d}, @ref{dummy}, @ref{isosamples}, @ref{offsets}, @ref{origin},
@ref{samples}, @ref{size}, `time`, and @ref{view}; lists of tics or the loop parameters
which specify them; the offsets for titles and axis labels; parametric
functions to be used to calculate the x, y, and z coordinates on the `plot`,
@ref{replot} and `splot` commands; and the complete sets of keywords specifying
individual plots (data sets or functions) on the `plot`, @ref{replot} and `splot`
commands.
Parentheses are used to delimit sets of explicit tics (as opposed to loop
parameters) and to indicate computations in the @ref{using} filter of the @ref{fit},
`plot`, @ref{replot} and `splot` commands.
(Parentheses and commas are also used as usual in function notation.)
Square brackets are used to delimit ranges given in `set`, `plot`
or `splot` commands.
Colons are used to separate extrema in `range` specifications (whether they
are given on `set`, `plot` or `splot` commands) and to separate entries in
the @ref{using} filter of the `plot`, @ref{replot}, `splot` and @ref{fit} commands.
Semicolons are used to separate commands given on a single command line.
Braces are used in text to be specially processed by some terminals, like
@ref{postscript}. They are also used to denote complex numbers: @{3,2@} = 3 + 2i.
At present you should not embed \n inside @{@} when using the PostScript
terminal in `enhanced text` mode.
The EEPIC, Imagen, Uniplex, LaTeX, and TPIC drivers allow a newline to be
specified by \\ in a single-quoted string or \\\\ in a double-quoted string.
@menu
* Quote_Marks::
@end menu
@node Quote_Marks, , Syntax, Syntax
@subsection Quote Marks
@cindex quotes
@c ?syntax quotes
Gnuplot uses three forms of quote marks for delimiting text strings,
double-quote (ascii 34), single-quote (ascii 39), and backquote (ascii 96).
Filenames may be entered with either single- or double-quotes. In this
manual the command examples generally single-quote filenames and double-quote
other string tokens for clarity.
String constants and text strings used for labels, titles, or other plot
elements may be enclosed in either single quotes or double quotes. Further
processing of the quoted text depends on the choice of quote marks.
Backslash processing of special characters like \n (newline) and
\345 (octal character code) is performed for double-quoted strings. In
single-quoted strings, backslashes are just ordinary characters. To get
a single-quote (ascii 39) in a single-quoted string, it has to be doubled.
Thus the strings "d\" s' b\\" and 'd" s'' b\' are completely equivalent.
Text justification is the same for each line of a multi-line string.
Thus the center-justified string
@example
"This is the first line of text.\nThis is the second line."
@end example
will produce
@example
This is the first line of text.
This is the second line.
@end example
but
@example
'This is the first line of text.\nThis is the second line.'
@end example
will produce
@example
This is the first line of text.\nThis is the second line.
@end example
Enhanced text processing is performed for both double-quoted text and
single-quoted text, but only by terminals supporting this mode.
See `enhanced text`.
Back-quotes are used to enclose system commands for substitution into the
command line. See `substitution`.
@node Time/Date_data, , Syntax, gnuplot
@section Time/Date data
@cindex time/date
@c ^
@c ^
`gnuplot` supports the use of time and/or date information as input data.
This feature is activated by the commands `set xdata time`, `set ydata time`,
etc.
Internally all times and dates are converted to the number of seconds from
the year 2000. The command @ref{timefmt} defines the format for all inputs:
data files, ranges, tics, label positions---in short, anything that accepts a
data value must receive it in this format. Since only one input format can
be in force at a given time, all time/date quantities being input at the same
time must be presented in the same format. Thus if both x and y data in a
file are time/date, they must be in the same format.
The conversion to and from seconds assumes Universal Time (which is the same
as Greenwich Standard Time). There is no provision for changing the time
zone or for daylight savings. If all your data refer to the same time zone
(and are all either daylight or standard) you don't need to worry about these
things. But if the absolute time is crucial for your application, you'll
need to convert to UT yourself.
Commands like @ref{xrange} will re-interpret the integer according to
@ref{timefmt}. If you change @ref{timefmt}, and then `show` the quantity again, it
will be displayed in the new @ref{timefmt}. For that matter, if you give the
deactivation command (like @ref{xdata}), the quantity will be shown in its
numerical form.
The commands `set format` or `set tics format` define the format that will be
used for tic labels, whether or not the specified axis is time/date.
If time/date information is to be plotted from a file, the @ref{using} option
_must_ be used on the `plot` or `splot` command. These commands simply use
white space to separate columns, but white space may be embedded within the
time/date string. If you use tabs as a separator, some trial-and-error may
be necessary to discover how your system treats them.
The following example demonstrates time/date plotting.
Suppose the file "data" contains records like
@example
03/21/95 10:00 6.02e23
@end example
This file can be plotted by
@example
set xdata time
set timefmt "%m/%d/%y"
set xrange ["03/21/95":"03/22/95"]
set format x "%m/%d"
set timefmt "%m/%d/%y %H:%M"
plot "data" using 1:3
@end example
which will produce xtic labels that look like "03/21".
See the descriptions of each command for more details.
@node plotting_styles, Commands, gnuplot, Top
@chapter plotting styles
@c ?plotting styles
There are many plotting styles available in gnuplot.
They are listed alphabetically below.
The commands `set style data` and `set style function` change the
default plotting style for subsequent `plot` and `splot` commands.
You also have the option to specify the plot style explicitly as part of
the `plot` or `splot` command. If you want to mix plot styles within a
single plot, you must specify the plot style for each component.
Example:
@example
plot 'data' with boxes, sin(x) with lines
@end example
Each plot style has its own expected set of data entries in a data file.
For example by default the `lines` style expects either a single column of
y values (with implicit x ordering) or a pair of columns with x in the first
and y in the second. For more information on how to fine-tune how columns in a
file are interpreted as plot data, see @ref{using}.
@menu
* boxerrorbars::
* boxes::
* boxxyerrorbars::
* candlesticks::
* circles::
* dots::
* filledcurves::
* financebars::
* fsteps::
* histeps::
* histograms::
* image::
* impulses::
* labels::
* lines::
* linespoints::
* points::
* steps::
* rgbalpha::
* rgbimage::
* vectors::
* xerrorbars::
* xyerrorbars::
* yerrorbars::
* xerrorlines::
* xyerrorlines::
* yerrorlines::
* 3D_(surface)_plots::
@end menu
@node boxerrorbars, boxes, plotting_styles, plotting_styles
@section boxerrorbars
@c ?commands set style boxerrorbars
@c ?set style boxerrorbars
@c ?plotting styles boxerrorbars
@c ?style boxerrorbars
@cindex boxerrorbars
The @ref{boxerrorbars} style is only relevant to 2D data plotting. It is a
combination of the @ref{boxes} and @ref{yerrorbars} styles. It uses 3, 4, or 5
columns of data:
@example
3 columns: x y ydelta
4 columns: x y ydelta xdelta # boxwidth != -2
4 columns: x y ylow yhigh # boxwidth == -2
5 columns: x y ylow yhigh xdelta
@end example
The boxwidth will come from the fourth column if the y errors are given as
"ydelta" and the boxwidth was not previously set to -2.0 (`set boxwidth -2.0`)
or from the fifth column if the y errors are in the form of "ylow yhigh". The
special case `boxwidth = -2.0` is for four-column data with y errors in the
form "ylow yhigh". In this case the boxwidth will be calculated so that each
box touches the adjacent boxes. The width will also be calculated in cases
where three-column data are used.
The box height is determined from the y error in the same way as it is for
the @ref{yerrorbars} style---either from y-ydelta to y+ydelta or from ylow to
yhigh, depending on how many data columns are provided.
See also
@uref{http://www.gnuplot.info/demo/mgr.html,errorbar demo.
}
@node boxes, boxxyerrorbars, boxerrorbars, plotting_styles
@section boxes
@c ?commands set style boxes
@c ?set style boxes
@c ?plotting styles boxes
@c ?style boxes
@cindex boxes
The @ref{boxes} style is only relevant to 2D plotting. It draws a box centered
about the given x coordinate that extends from the x axis (not from the graph
border) to the given y coordinate. It uses 2 or 3 columns of basic data.
Additional input columns may be used to provide information such as
variable line or fill color (see `rgbcolor variable`).
@example
2 columns: x y
3 columns: x y x_width
@end example
The width of the box is obtained in one of three ways. If the input data has a
third column, this will be used to set the width of the box. If not, if a
width has been set using the @ref{boxwidth} command, this will be used.
If neither of these is available, the width of each box will be calculated
automatically so that it touches the adjacent boxes.
The interior of the boxes is drawn according to the current fillstyle.
See `set style fill` for details. Alternatively a new fillstyle
may be specified in the plot command.
For fillstyle `empty` the box is not filled.
For fillstyle `solid` the box is filled with a solid rectangle of the
current drawing color. There is an optional parameter that
controls the fill density; it runs from 0 (background color) to 1
(current drawing color).
For fillstyle `pattern` the box is filled in the current drawing color with
a pattern, if supported by the terminal driver.
Examples:
To plot a data file with solid filled boxes with a small vertical space
separating them (bargraph):
@example
set boxwidth 0.9 relative
set style fill solid 1.0
plot 'file.dat' with boxes
@end example
To plot a sine and a cosine curve in pattern-filled boxes style:
@example
set style fill pattern
plot sin(x) with boxes, cos(x) with boxes
@end example
The sin plot will use pattern 0; the cos plot will use pattern 1.
Any additional plots would cycle through the patterns supported by the
terminal driver.
To specify explicit fillstyles for each dataset:
@example
plot 'file1' with boxes fs solid 0.25, \
'file2' with boxes fs solid 0.50, \
'file3' with boxes fs solid 0.75, \
'file4' with boxes fill pattern 1, \
'file5' with boxes fill empty
@end example
@node boxxyerrorbars, candlesticks, boxes, plotting_styles
@section boxxyerrorbars
@c ?commands set style boxxyerrorbars
@c ?set style boxxyerrorbars
@c ?plotting styles boxxyerrorbars
@c ?style boxxyerrorbars
@cindex boxxyerrorbars
The @ref{boxxyerrorbars} style is only relevant to 2D data plotting. It is similar
to the @ref{xyerrorbars} style except that it draws rectangular areas rather than
simple crosses. It uses either 4 or 6 basic columns of input data.
Additional input columns may be used to provide information such as
variable line or fill color (see `rgbcolor variable`).
@example
4 columns: x y xdelta ydelta
6 columns: x y xlow xhigh ylow yhigh
@end example
The box width and height are determined from the x and y errors in the same
way as they are for the @ref{xyerrorbars} style---either from xlow to xhigh and
from ylow to yhigh, or from x-xdelta to x+xdelta and from y-ydelta to
y+ydelta, depending on how many data columns are provided.
The interior of the boxes is drawn according to the current fillstyle.
See `set style fill` and @ref{boxes} for details. Alternatively a new fillstyle
may be specified in the plot command.
@node candlesticks, circles, boxxyerrorbars, plotting_styles
@section candlesticks
@c ?commands set style candlesticks
@c ?set style candlesticks
@c ?plotting styles candlesticks
@c ?style candlesticks
@cindex candlesticks
The @ref{candlesticks} style can be used for 2D data plotting of financial
data or for generating box-and-whisker plots of statistical data.
The symbol is a rectangular box, centered horizontally at the x
coordinate and limited vertically by the opening and closing prices. A
vertical line segment at the x coordinate extends up from the top of the
rectangle to the high price and another down to the low. The vertical line
will be unchanged if the low and high prices are interchanged.
Five columns of basic data are required:
@example
financial data: date open low high close
whisker plot: x box_min whisker_min whisker_high box_high
@end example
The width of the rectangle can be controlled by the @ref{boxwidth} command.
For backwards compatibility with earlier gnuplot versions, when the
boxwidth parameter has not been set then the width of the candlestick
rectangle is controlled by `set bars `.
By default the vertical line segments have no crossbars at the top and
bottom. If you want crossbars, which are typically used for box-and-whisker
plots, then add the keyword `whiskerbars` to the plot command. By default
these whiskerbars extend the full horizontal width of the candlestick, but
you can modify this by specifying a fraction of the full width.
The usual convention for financial data is that the rectangle is empty
if (open < close) and solid fill if (close < open). This is the behavior you
will get if the current fillstyle is set to "empty". See `fillstyle`.
If you set the fillstyle to solid or pattern, then this will be used for
all boxes independent of open and close values.
See also @ref{bars} and @ref{financebars}. See also the
@uref{http://gnuplot.sourceforge.net/demo/candlesticks.html,candlestick
}
and
@uref{http://gnuplot.sourceforge.net/demo/finance.html,finance
}
demos.
Note: To place additional symbols, such as the median value, on a
box-and-whisker plot requires additional plot commands as in this example:
@example
# Data columns:X Min 1stQuartile Median 3rdQuartile Max
set bars 4.0
set style fill empty
plot 'stat.dat' using 1:3:2:6:5 with candlesticks title 'Quartiles', \
'' using 1:4:4:4:4 with candlesticks lt -1 notitle
@end example
@example
# Plot with crossbars on the whiskers, crossbars are 50% of full width
plot 'stat.dat' using 1:3:2:6:5 with candlesticks whiskerbars 0.5
@end example
See @ref{boxwidth}, @ref{bars} and `set style fill`.
@node circles, dots, candlesticks, plotting_styles
@section circles
@c ?commands set style circles
@c ?set style circles
@c ?plotting styles circles
@c ?style circles
@cindex circles
The @ref{circles} style plots a circle with an explicit radius at each data point.
Three columns of data are required: x, y, radius. An optional 4th column may
be used to specify color information. The radius is always interpreted in the
units of the plot's horizontal axis (x or x2). The scale on y and the aspect
ratio of the plot are both ignored.
Example (draws circles whose area is proportional to the value in column 3):
@example
set style fill transparent solid 0.2 noborder
plot 'data' using 1:2:(sqrt($3)) with circles, \
'data' using 1:2 with linespoints
@end example
The result is similar to using a `points` plot with variable size points and
pointstyle 6, except that the circles will scale with the x axis range.
See also `set object circle` and `fillstyle`.
@node dots, filledcurves, circles, plotting_styles
@section dots
@c ?commands set style dots
@c ?set style dots
@c ?plotting styles dots
@c ?style dots
@cindex dots
The @ref{dots} style plots a tiny dot at each point; this is useful for scatter
plots with many points. Either 1 or 2 columns of input data are required in
2D. Three columns are required in 3D.
For some terminals (post, pdf) the size of the dot can be controlled by
changing the linewidth.
@example
1 column y # x is row number
2 columns: x y
3 columns: x y z # 3D only (splot)
@end example
@node filledcurves, financebars, dots, plotting_styles
@section filledcurves
@c ?commands set style filledcurves
@c ?set style filledcurves
@c ?plotting styles filledcurves
@c ?style filledcurves
@cindex filledcurves
The @ref{filledcurves} style is only relevant to 2D plotting. Three variants
are possible. The first two variants require either a function or two columns
of input data, and may be further modified by the options listed below.
Syntax:
@example
plot ... with filledcurves [option]
@end example
where the option can be one of the following
@example
[closed | @{above | below@}
@{x1 | x2 | y1 | y2@}[=] | xy=,]
@end example
The first variant, `closed`, treats the curve itself as a closed polygon.
This is the default if there are two columns of input data.
The second variant is to fill the area between the curve and a given axis,
a horizontal or vertical line, or a point.
@example
filledcurves closed ... just filled closed curve,
filledcurves x1 ... x1 axis,
filledcurves x2 ... x2 axis, etc for y1 and y2 axes,
filledcurves y1=0 ... line y=0 (at y1 axis) ie parallel to x1 axis,
filledcurves y2=42 ... line y=42 (at y2 axis) ie parallel to x2, etc,
filledcurves xy=10,20 ... point 10,20 of x1,y1 axes (arc-like shape).
@end example
The third variant requires three columns of input data: the x coordinate and
two y coordinates corresponding to two curves sampled at the same set of
x coordinates; the area between the two curves is filled.
This is the default if there are three or more columns of input data.
@example
3 columns: x y1 y2
@end example
Example of filling the area between two input curves.
@uref{http://www.gnuplot.info/demo/fillbetween.html,fill between curves demo.
}
@example
plot 'data' using 1:2:3 with filledcurves
@end example
The `above` and `below` options apply both to commands of the form
@example
... filledcurves above @{x1|x2|y1|y2@}=
@end example
and to commands of the form
@example
... using 1:2:3 with filledcurves below
@end example
In either case the option limits the filled area to one side of the bounding
line or curve.
Note: Not all terminal types support this plotting mode.
Zooming a filled curve drawn from a datafile may produce empty or incorrect
areas because gnuplot is clipping points and lines, and not areas.
If the values of , , are out of the drawing boundary, then they
are moved to the graph boundary. Then the actually filled area in the case
of option xy=, will depend on xrange and yrange.
@node financebars, fsteps, filledcurves, plotting_styles
@section financebars
@c ?commands set style financebars
@c ?set style financebars
@c ?plotting styles financebars
@c ?style financebars
@cindex financebars
The @ref{financebars} style is only relevant for 2D data plotting of financial
data. It requires 1 x coordinate (usually a date) and 4 y values (prices).
@example
5 columns: date open low high close
@end example
The symbol is a vertical line segment, located horizontally at the x
coordinate and limited vertically by the high and low prices. A horizontal
tic on the left marks the opening price and one on the right marks the
closing price. The length of these tics may be changed by @ref{bars}. The
symbol will be unchanged if the high and low prices are interchanged.
See @ref{bars} and @ref{candlesticks}, and also the
@uref{http://www.gnuplot.info/demo/finance.html,finance demo.
}
@node fsteps, histeps, financebars, plotting_styles
@section fsteps
@c ?commands set style fsteps
@c ?set style fsteps
@c ?plotting styles fsteps
@c ?style fsteps
@cindex fsteps
The @ref{fsteps} style is only relevant to 2D plotting. It connects consecutive
points with two line segments: the first from (x1,y1) to (x1,y2) and the
second from (x1,y2) to (x2,y2). The input column requires are the same as for
plot styles `lines` and `points`. The difference between @ref{fsteps} and @ref{steps}
is that @ref{fsteps} traces first the change in y and then the change in x.
@ref{steps} traces first the change in x and then the change in y.
See also
@uref{http://www.gnuplot.info/demo/steps.html,steps demo.
}
@node histeps, histograms, fsteps, plotting_styles
@section histeps
@c ?commands set style histeps
@c ?set style histeps
@c ?plotting styles histeps
@c ?style histeps
@cindex histeps
The @ref{histeps} style is only relevant to 2D plotting. It is intended for
plotting histograms. Y-values are assumed to be centered at the x-values;
the point at x1 is represented as a horizontal line from ((x0+x1)/2,y1) to
((x1+x2)/2,y1). The lines representing the end points are extended so that
the step is centered on at x. Adjacent points are connected by a vertical
line at their average x, that is, from ((x1+x2)/2,y1) to ((x1+x2)/2,y2).
The input column requires are the same as for plot styles `lines` and `points`.
If @ref{autoscale} is in effect, it selects the xrange from the data rather than
the steps, so the end points will appear only half as wide as the others.
See also
@uref{http://www.gnuplot.info/demo/steps.html,steps demo.
}
@ref{histeps} is only a plotting style; `gnuplot` does not have the ability to
create bins and determine their population from some data set.
@node histograms, image, histeps, plotting_styles
@section histograms
@c ?commands set style histogram
@c ?set style histogram
@c ?style histograms
@c ?plotting styles histograms
@cindex histograms
The @ref{histograms} style is only relevant to 2D plotting. It produces a bar
chart from a sequence of parallel data columns. Each element of the `plot`
command must specify a single input data source (e.g. one column of the input
file), possibly with associated tic values or key titles.
Four styles of histogram layout are currently supported.
@example
set style histogram clustered @{gap @}
set style histogram errorbars @{gap @} @{@}
set style histogram rowstacked
set style histogram columnstacked
@end example
The default style corresponds to `set style histogram clustered gap 2`.
In this style, each set of parallel data values is collected into a group of
boxes clustered at the x-axis coordinate corresponding to their sequential
position (row #) in the selected datafile columns. Thus if datacolumns are
selected, the first cluster is centered about x=1, and contains boxes whose
heights are taken from the first entry in the corresponding data columns.
This is followed by a gap and then a second cluster of boxes centered about x=2
corresponding to the second entry in the respective data columns, and so on.
The default gap width of 2 indicates that the empty space between clusters is
equivalent to the width of 2 boxes. All boxes derived from any one column
are given the same fill color and/or pattern (see `set style fill`).
Each cluster of boxes is derived from a single row of the input data file.
It is common in such input files that the first element of each row is a
label. Labels from this column may be placed along the x-axis underneath
the appropriate cluster of boxes with the `xticlabels` option to @ref{using}.
The @ref{errorbars} style is very similar to the `clustered` style, except that it
requires additional columns of input for each entry. The first column holds
the height (y value) of that box, exactly as for the `clustered` style.
@example
2 columns: y yerr bar extends from y-yerr to y+err
3 columns: y ymin yman bar extends from ymin to ymax
@end example
The appearance of the error bars is controlled by the current value of
@ref{bars} and by the optional specification.
Two styles of stacked histogram are supported, chosen by the command
`set style histogram @{rowstacked|columnstacked@}`. In these styles the data
values from the selected columns are collected into stacks of boxes.
Positive values stack upwards from y=0; negative values stack downwards.
Mixed positive and negative values will produce both an upward stack and a
downward stack. The default stacking mode is `rowstacked`.
The `rowstacked` style places a box resting on the x-axis for each
data value in the first selected column; the first data value results in
a box a x=1, the second at x=2, and so on. Boxes corresponding to the
second and subsequent data columns are layered on top of these, resulting
in a stack of boxes at x=1 representing the first data value from each
column, a stack of boxes at x=2 representing the second data value from
each column, and so on. All boxes derived from any one column are given the
same fill color and/or pattern (see `set style fill`).
The `columnstacked` style is similar, except that each stack of boxes is
built up from a single data column. Each data value from the first specified
column yields a box in the stack at x=1, each data value from the second
specified column yields a box in the stack at x=2, and so on. In this style
the color of each box is taken from the row number, rather than the column
number, of the corresponding data field.
Box widths may be modified using the @ref{boxwidth} command.
Box fill styles may be set using the `set style fill` command.
Histograms always use the x1 axis, but may use either y1 or y2.
If a plot contains both histograms and other plot styles, the non-histogram
plot elements may use either the x1 or the x2 axis.
Examples:
Suppose that the input file contains data values in columns 2, 4, 6, ...
and error estimates in columns 3, 5, 7, ... This example plots the values
in columns 2 and 4 as a histogram of clustered boxes (the default style).
Because we use iteration in the plot command, any number of data columns can
be handled in a single command. See @ref{iteration}.
@example
set boxwidth 0.9 relative
set style data histograms
set style histogram cluster
set style fill solid 1.0 border lt -1
plot for [COL=2:4:2] 'file.dat' using COL
@end example
This will produce a plot with clusters of two boxes (vertical bars) centered
at each integral value on the x axis. If the first column of the input file
contains labels, they may be placed along the x-axis using the variant command
@example
plot for [COL=2:4:2] 'file.dat' using COL:xticlabels(1)
@end example
If the file contains both magnitude and range information for each value,
then error bars can be added to the plot. The following commands will add
error bars extending from (y-) to (y+), capped by horizontal bar
ends drawn the same width as the box itself. The error bars and bar ends are
drawn with linewidth 2, using the border linetype from the current fill style.
@example
set bars fullwidth
set style fill solid 1 border lt -1
set style histogram errorbars gap 2 lw 2
plot for [COL=2:4:2] 'file.dat' using COL:COL+1
@end example
To plot the same data as a rowstacked histogram. Just to be different, this
example lists the separate columns explicitly rather than using iteration.
@example
set style histogram rowstacked
plot 'file.dat' using 2, '' using 4:xtic(1)
@end example
This will produce a plot in which each vertical bar corresponds to one row of
data. Each vertical bar contains a stack of two segments, corresponding in
height to the values found in columns 2 and 4 of the datafile.
Finally, the commands
@example
set style histogram columnstacked
plot 'file.dat' using 2, '' using 4
@end example
will produce two vertical stacks, one for each column of data. The stack at
x=1 will contain a box for each entry in column 2 of the datafile. The stack
at x=2 will contain a box for each parallel entry in column 4 of the datafile.
Because this interchanges gnuplot's usual interpretation of input rows and
columns, the specification of key titles and x-axis tic labels must also be
modified accordingly. See the comments given below.
@example
set style histogram columnstacked
plot '' u 5:key(1) # uses first column to generate key titles
plot '' u 5 title columnhead # uses first row to generate xtic labels
@end example
Note that the two examples just given present exactly the same data values,
but in different formats.
@menu
* newhistogram::
* automated_iteration_over_multiple_columns::
@end menu
@node newhistogram, automated_iteration_over_multiple_columns, histograms, histograms
@subsection newhistogram
@cindex newhistogram
@c ?histograms newhistogram
@c ?plotting style histograms newhistogram
More than one set of histograms can appear in a single plot. In this case you
can force a gap between them, and a separate label for each set, by using the
plot command `newhistogram @{""@} @{@}`.
For example
@example
set style histogram cluster
plot newhistogram "Set A", 'a' using 1, '' using 2, '' using 3, \
newhistogram "Set B", 'b' using 1, '' using 2, '' using 3
@end example
The labels "Set A" and "Set B" will appear beneath the respective sets of
histograms, under the overall x axis label.
The newhistogram command can also be used to force histogram coloring to
begin with a specific color (linetype). By default colors will continue to
increment successively even across histogram boundaries. Here is an example
using the same coloring for multiple histograms
@example
plot newhistogram "Set A" lt 4, 'a' using 1, '' using 2, '' using 3, \
newhistogram "Set B" lt 4, 'b' using 1, '' using 2, '' using 3
@end example
The `at ` option only applies to column-stacked histograms.
@node automated_iteration_over_multiple_columns, , newhistogram, histograms
@subsection automated iteration over multiple columns
@cindex automated
@c ?histograms automated
@c ?styles histograms automated
@c ?plotting styles histograms automated
If you want to create a histogram from many columns of data in a single file,
it is very convenient to use the plot iteration feature. See @ref{iteration}.
For example, to create stacked histograms of the data in columns 3 through 8
@example
set style histogram columnstacked
plot for [i=3:8] "datafile" using i title columnhead
@end example
@node image, impulses, histograms, plotting_styles
@section image
@c ?commands set style image
@c ?set style image
@c ?plotting styles image
@c ?style image
@cindex image
@cindex rgbimage
@cindex rgbalpha
The `image`, @ref{rgbimage}, and @ref{rgbalpha} plotting styles all project an input 2D
image onto either a 2D or 3D plot. It is assumed that the image data forms an
equidistant sampling grid in the viewing plane along two, not necessarily
orthogonal, directions. In other words, each group of four adjacent points is
assumed to form a uniformly sized parallelogram. The paralleogram is painted
using the color of the corresponding pixel in the input image.
Each pixel (data point) of the input 2D image will become a rectangle or
parallelipiped in the plot. The coordinates of each data point will determine
the center of the parallelipiped. That is, an M x N set of data will form an
image with M x N pixels. This is different from the pm3d plotting style, where
an M x N set of data will form a surface of (M-1) x (N-1) elements. The scan
directions for a binary image data grid can be further controlled by additional
keywords. See `binary general keywords flipx`, `center`, and `rotate`.
The `image` style handles input pixels containing a grayscale or color palette
value. Thus 2D plots (`plot` command) require 3 columns of data (x,y,value),
while 3D plots (`splot` command) require 4 columns of data (x,y,z,value).
The @ref{rgbimage} style handles input pixels that are described by three separate
values for the red, green, and blue components. Thus 5D data (x,y,r,g,b) is
needed for `plot` and 6D data (x,y,z,r,g,b) for `splot`. The individual red,
green, and blue components are assumed to lie in the range [0:255].
The @ref{rgbalpha} style handles input pixels that contain alpha channel
(transparency) information in addition to the red, green, and blue components.
Thus 6D data (x,y,r,g,b,a) is needed for `plot` and 7D data (x,y,z,r,g,b,a)
for `splot`. The r, g, b, and alpha components are assumed to lie in the range
[0:255].
@menu
* transparency::
* image_failsafe::
@end menu
@node transparency, image_failsafe, image, image
@subsection transparency
@c ?image transparency
@cindex transparency
@c ?alpha channel
The @ref{rgbalpha} plotting style assumes that each pixel of input data contains
an alpha value in the range [0:255]. A pixel with alpha = 0 is purely
transparent and does not alter the underlying contents of the plot. A pixel
with alpha = 255 is purely opaque. All terminal types can handle these two
extreme cases. A pixel with 0 < alpha < 255 is partially transparent.
Only a few terminal types can handle this correctly; other terminals will
approximate this by treating alpha as being either 0 or 255.
@node image_failsafe, , transparency, image
@subsection image failsafe
@c ?commands set style image failsafe
@c ?set style image failsafe
@c ?plotting styles image failsafe
@c ?style image failsafe
@c ?image failsafe
@cindex failsafe
Some terminal drivers provide code to optimize rendering of image data
within a rectangular 2D area. However this code is known to be imperfect.
This optimized code may be disabled by using the keyword `failsafe`. E.g.
@example
plot 'data' with image failsafe
@end example
@node impulses, labels, image, plotting_styles
@section impulses
@c ?commands set style impulses
@c ?set style impulses
@c ?plotting styles impulses
@c ?style impulses
@cindex impulses
The @ref{impulses} style displays a vertical line from the x axis to the y value
of each point (2D) or from the xy plane to the z value of each point (3D).
Note that the y or z values may be negative. As with most plot styles, data
from additional columns can be used to control the color of each impulse.
To use this style effectively in 3D plots, it is useful to use thick lines
(linewidth > 1). This approximates a 3D bar chart.
@example
1 column: y # implicit x coordinate from row number (2D)
2 columns: x y # line from [x,0] to [x,y] (2D)
3 columns: x y z # line from [x,y,0] to [x,y,z] (3D)
@end example
@node labels, lines, impulses, plotting_styles
@section labels
@c ?commands set style labels
@c ?set style labels
@c ?plotting styles labels
@c ?style labels
@cindex labels
The @ref{labels} style reads coordinates and text from a data file and places
the text string at the corresponding 2D or 3D position. 3 or 4 input columns
of basic data are required. Additional input columns may be used to provide
information such as variable font size or text color (see `rgbcolor variable`).
@example
3 columns: x y string # 2D version
4 columns: x y z string # 3D version
@end example
The font, color, rotation angle and other properties of the printed text
may be specified as additional command options (see `set label`). The example
below generates a 2D plot with text labels constructed from the city whose
name is taken from column 1 of the input file, and whose geographic coordinates
are in columns 4 and 5. The font size is calculated from the value in column 3,
in this case the population.
@example
CityName(String,Size) = sprintf("@{/=%d %s@}", Scale(Size), String)
plot 'cities.dat' using 5:4:(CityName(stringcolumn(1),$3)) with labels
@end example
If we did not want to adjust the font size to a different size for each city
name, the command would be much simpler:
@example
plot 'cities.dat' using 5:4:1 with labels font "Times,8"
@end example
The @ref{labels} style can also be used in 3D plots. In this case four input
column specifiers are required, corresponding to X Y Z and text.
@example
splot 'datafile' using 1:2:3:4 with labels
@end example
See also `datastrings`, `set style data`.
@node lines, linespoints, labels, plotting_styles
@section lines
@c ?commands set style lines
@c ?set style lines
@c ?plotting styles lines
@c ?style lines
@cindex lines
The `lines` style connects adjacent points with straight line segments.
It may be used in either 2D or 3D plots. The basic form requires 1, 2, or 3
columns of input data.
Additional input columns may be used to provide information such as
variable line color (see `rgbcolor variable`).
2D form
@example
1 column: y # implicit x from row number
2 columns: x y
@end example
3D form
@example
1 column: z # implicit x from row, y from index
3 columns: x y z
@end example
See also `linetype`, `linewidth`, and `linestyle`.
@node linespoints, points, lines, plotting_styles
@section linespoints
@c ?commands set style linespoints
@c ?commands set style lp
@c ?set style linespoints
@c ?plotting styles linespoints
@c ?set style lp
@c ?style linespoints
@c ?style lp
@cindex linespoints
@cindex lp
The @ref{linespoints} style does both `lines` and `points`, that is, it draws a
small symbol at each point and then connects adjacent points with straight
line segments. The command @ref{pointsize} may be used to change the size of
the points. See @ref{pointsize} for its usage.
1 or 2 columns of basic input data are required in 2D plots; 1 or 3 columns are
required if 3D plots. See `style lines`. Additional input columns may be used
to provide information such as variable point size or line color.
@ref{linespoints} may be abbreviated `lp`.
@node points, steps, linespoints, plotting_styles
@section points
@c ?commands set style points
@c ?set style points
@c ?plotting styles points
@c ?style points
@cindex points
The `points` style displays a small symbol at each point. The command @ref{pointsize} may be used to change the default size of the points.
1 or 2 columns of basic input data are required in 2D plots; 1 or 3 columns are
required if 3D plots. See `style lines`. Additional input columns may be used
to provide information such as variable point size or line color.
@node steps, rgbalpha, points, plotting_styles
@section steps
@c ?commands set style steps
@c ?set style steps
@c ?plotting styles steps
@c ?style steps
@cindex steps
The @ref{steps} style is only relevant to 2D plotting. It connects consecutive
points with two line segments: the first from (x1,y1) to (x2,y1) and the
second from (x2,y1) to (x2,y2). The input column requires are the same as for
plot styles `lines` and `points`. The difference between @ref{fsteps} and @ref{steps}
is that @ref{fsteps} traces first the change in y and then the change in x.
@ref{steps} traces first the change in x and then the change in y.
See also
@uref{http://www.gnuplot.info/demo/steps.html,steps demo.
}
@node rgbalpha, rgbimage, steps, plotting_styles
@section rgbalpha
@c ?commands set style rgbalpha
@c ?set style rgbalpha
@c ?plotting styles rgbalpha
@c ?style rgbalpha
See `image`.
@node rgbimage, vectors, rgbalpha, plotting_styles
@section rgbimage
@c ?commands set style rgbimage
@c ?set style rgbimage
@c ?plotting styles rgbimage
@c ?style rgbimage
See `image`.
@node vectors, xerrorbars, rgbimage, plotting_styles
@section vectors
@c ?commands set style vectors
@c ?set style vectors
@c ?plotting styles vectors
@c ?style vectors
@cindex vectors
The 2D @ref{vectors} style draws a vector from (x,y) to (x+xdelta,y+ydelta).
The 3D @ref{vectors} style is similar, but requires six columns of basic data.
A small arrowhead is drawn at the end of each vector.
@example
4 columns: x y xdelta ydelta
6 columns: x y z xdelta ydelta zdelta
@end example
splot with vectors is supported only for `set mapping cartesian`.
The keywords "with vectors" may be followed by arrow style specifications.
See `arrowstyle` for more details.
Example:
@example
plot 'file.dat' using 1:2:3:4 with vectors head filled lt 2
splot 'file.dat' using 1:2:3:(1):(1):(1) with vectors filled head lw 2
@end example
`set clip one` and `set clip two` affect vectors drawn in 2D.
Please see @ref{clip} and `arrowstyle`.
@node xerrorbars, xyerrorbars, vectors, plotting_styles
@section xerrorbars
@c ?commands set style xerrorbars
@c ?set style xerrorbars
@c ?plotting styles xerrorbars
@c ?style xerrorbars
@cindex xerrorbars
The @ref{xerrorbars} style is only relevant to 2D data plots. @ref{xerrorbars} is
like @ref{dots}, except that a horizontal error bar is also drawn. At each point
(x,y), a line is drawn from (xlow,y) to (xhigh,y) or from (x-xdelta,y) to
(x+xdelta,y), depending on how many data columns are provided. A tic mark
is placed at the ends of the error bar (unless @ref{bars} is used---see
@ref{bars} for details). The basic style requires either 3 or 4 columns:
@example
3 columns: x y xdelta
4 columns: x y xlow xhigh
@end example
@node xyerrorbars, yerrorbars, xerrorbars, plotting_styles
@section xyerrorbars
@c ?commands set style xyerrorbars
@c ?set style xyerrorbars
@c ?plotting styles xyerrorbars
@c ?style xyerrorbars
@cindex xyerrorbars
The @ref{xyerrorbars} style is only relevant to 2D data plots. @ref{xyerrorbars} is
like @ref{dots}, except that horizontal and vertical error bars are also drawn.
At each point (x,y), lines are drawn from (x,y-ydelta) to (x,y+ydelta) and
from (x-xdelta,y) to (x+xdelta,y) or from (x,ylow) to (x,yhigh) and from
(xlow,y) to (xhigh,y), depending upon the number of data columns provided. A
tic mark is placed at the ends of the error bar (unless @ref{bars} is
used---see @ref{bars} for details). Either 4 or 6 input columns are required.
@example
4 columns: x y xdelta ydelta
6 columns: x y xlow xhigh ylow yhigh
@end example
If data are provided in an unsupported mixed form, the @ref{using} filter on the
`plot` command should be used to set up the appropriate form. For example,
if the data are of the form (x,y,xdelta,ylow,yhigh), then you can use
@example
plot 'data' using 1:2:($1-$3):($1+$3):4:5 with xyerrorbars
@end example
@node yerrorbars, xerrorlines, xyerrorbars, plotting_styles
@section yerrorbars
@c ?commands set style yerrorbars
@c ?commands set style errorbars
@c ?plotting styles yerrorbars
@c ?plotting styles errorbars
@c ?set style yerrorbars
@c ?set style errorbars
@c ?style yerrorbars
@c ?style errorbars
@cindex yerrorbars
The @ref{yerrorbars} (or @ref{errorbars}) style is only relevant to 2D data plots.
@ref{yerrorbars} is like `points`, except that a vertical error bar is also drawn.
At each point (x,y), a line is drawn from (x,y-ydelta) to (x,y+ydelta) or
from (x,ylow) to (x,yhigh), depending on how many data columns are provided.
A tic mark is placed at the ends of the error bar (unless @ref{bars} is
used---see @ref{bars} for details). Either 3 or 4 input columns are required.
@example
3 columns: x y ydelta
4 columns: x y ylow yhigh
@end example
See also
@uref{http://www.gnuplot.info/demo/mgr.html,errorbar demo.
}
@node xerrorlines, xyerrorlines, yerrorbars, plotting_styles
@section xerrorlines
@c ?commands set style xerrorlines
@c ?set style xerrorlines
@c ?plotting styles xerrorlines
@c ?style xerrorlines
@cindex xerrorlines
The @ref{xerrorlines} style is only relevant to 2D data plots.
@ref{xerrorlines} is like @ref{linespoints}, except that a horizontal error
line is also drawn. At each point (x,y), a line is drawn from (xlow,y)
to (xhigh,y) or from (x-xdelta,y) to (x+xdelta,y), depending on how
many data columns are provided. A tic mark is placed at the ends of
the error bar (unless @ref{bars} is used---see @ref{bars} for details).
The basic style requires either 3 or 4 columns:
@example
3 columns: x y xdelta
4 columns: x y xlow xhigh
@end example
@node xyerrorlines, yerrorlines, xerrorlines, plotting_styles
@section xyerrorlines
@c ?commands set style xyerrorlines
@c ?set style xyerrorlines
@c ?plotting styles xyerrorlines
@c ?style xyerrorlines
@cindex xyerrorlines
The @ref{xyerrorlines} style is only relevant to 2D data plots.
@ref{xyerrorlines} is like @ref{linespoints}, except that horizontal and
vertical error bars are also drawn. At each point (x,y), lines are
drawn from (x,y-ydelta) to (x,y+ydelta) and from (x-xdelta,y) to
(x+xdelta,y) or from (x,ylow) to (x,yhigh) and from (xlow,y) to
(xhigh,y), depending upon the number of data columns provided. A tic
mark is placed at the ends of the error bar (unless @ref{bars} is
used---see @ref{bars} for details). Either 4 or 6 input columns are required.
@example
4 columns: x y xdelta ydelta
6 columns: x y xlow xhigh ylow yhigh
@end example
If data are provided in an unsupported mixed form, the @ref{using} filter on the
`plot` command should be used to set up the appropriate form. For example,
if the data are of the form (x,y,xdelta,ylow,yhigh), then you can use
@example
plot 'data' using 1:2:($1-$3):($1+$3):4:5 with xyerrorlines
@end example
@node yerrorlines, 3D_(surface)_plots, xyerrorlines, plotting_styles
@section yerrorlines
@c ?commands set style yerrorlines
@c ?commands set style errorlines
@c ?plotting styles yerrorlines
@c ?plotting styles errorlines
@c ?set style yerrorlines
@c ?set style errorlines
@c ?style yerrorlines
@c ?style errorlines
@cindex yerrorlines
The @ref{yerrorlines} (or @ref{errorlines}) style is only relevant to 2D data
plots. @ref{yerrorlines} is like @ref{linespoints}, except that a vertical
error line is also drawn. At each point (x,y), a line is drawn from
(x,y-ydelta) to (x,y+ydelta) or from (x,ylow) to (x,yhigh), depending
on how many data columns are provided. A tic mark is placed at the
ends of the error bar (see @ref{bars} for details).
Either 3 or 4 input columns are required.
@example
3 columns: x y ydelta
4 columns: x y ylow yhigh
@end example
See also
@uref{http://www.gnuplot.info/demo/mgr.html,errorbar demo.
}
@node 3D_(surface)_plots, , yerrorlines, plotting_styles
@section 3D (surface) plots
@c ?3D (surface) plots
@c ?plotting styles 3d (surface) plots
Surface plots are generated using the `splot` command rather than the `plot`
command. The style `with lines` draws a surface made from a grid of lines.
Solid surfaces can be drawn using the style @ref{pm3d}.
Usually the surface is displayed at some arbitrary viewing angle,
such that it clearly represents a 3D surface. In this case the X, Y, and Z
axes are all visible in the plot. The illusion of 3D is enhanced by choosing
hidden line removal or depth-sorted surface elements.
See @ref{hidden3d} and the @ref{depthorder} option of @ref{pm3d}.
The `splot` command can also calculate and draw contour lines corresponding
to constant Z values. These contour lines may be drawn onto the surface
itself, or projected onto the XY plane. See @ref{contour}.
An important special case of the `splot` command is to map the Z coordinate
onto a 2D surface by projecting the plot along the Z axis. See `set view map`.
This plot mode can be used to generate contour plots and heat maps.
@node Commands, Terminal_types, plotting_styles, Top
@chapter Commands
@cindex commands
This section lists the commands acceptable to `gnuplot` in alphabetical
order. Printed versions of this document contain all commands; the text
available interactively may not be complete. Indeed, on some systems there may
be no commands at all listed under this heading.
Note that in most cases unambiguous abbreviations for command names and their
options are permissible, i.e., "`p f(x) w li`" instead of "`plot f(x) with
lines`".
In the syntax descriptions, braces (@{@}) denote optional arguments and a
vertical bar (|) separates mutually exclusive choices.
@menu
* cd::
* call::
* clear::
* evaluate::
* exit::
* fit::
* help::
* history::
* if::
* iteration::
* load::
* lower::
* pause::
* plot::
* print::
* pwd::
* quit::
* raise::
* refresh::
* replot::
* reread::
* reset::
* save::
* set-show::
* shell::
* splot::
* system_::
* test::
* undefine::
* unset::
* update::
@end menu
@node cd, call, Commands, Commands
@section cd
@c ?commands cd
@cindex cd
@cmindex cd
The @ref{cd} command changes the working directory.
Syntax:
@example
cd ''
@end example
The directory name must be enclosed in quotes.
Examples:
@example
cd 'subdir'
cd ".."
@end example
It is recommended that Windows users use single-quotes, because backslash [\]
has special significance inside double-quotes and has to be escaped.
For example,
@example
cd "c:\newdata"
@end example
fails, but
@example
cd 'c:\newdata'
cd "c:\\newdata"
@end example
work as expected.
@node call, clear, cd, Commands
@section call
@c ?commands call
@cindex call
@cmindex call
The @ref{call} command is identical to the load command with one exception: you
can have up to ten additional parameters to the command (delimited according
to the standard parser rules) which can be substituted into the lines read
from the file. As each line is read from the @ref{call}ed input file, it is
scanned for the sequence `$` (dollar-sign) followed by a digit (0--9). If
found, the sequence is replaced by the corresponding parameter from the
@ref{call} command line. If the parameter was specified as a string in the
@ref{call} line, it is substituted without its enclosing quotes. Sequence `$#`
is replaced by the number of passed parameters. `$` followed by any character
will be that character; e.g. use `$$` to get a single `$`. Providing more
than ten parameters on the @ref{call} command line will cause an error. A
parameter that was not provided substitutes as nothing. Files being @ref{call}ed
may themselves contain @ref{call} or `load` commands.
Syntax:
@example
call "" ...
@end example
The name of the input file must be enclosed in quotes, and it is recommended
that parameters are similarly enclosed in quotes (future versions of gnuplot
may treat quoted and unquoted arguments differently).
Example:
If the file 'calltest.gp' contains the line:
@example
print "argc=$# p0=$0 p1=$1 p2=$2 p3=$3 p4=$4 p5=$5 p6=$6 p7=x$7x"
@end example
entering the command:
@example
call 'calltest.gp' "abcd" 1.2 + "'quoted'" -- "$2"
@end example
will display:
@example
argc=7 p0=abcd p1=1.2 p2=+ p3='quoted' p4=- p5=- p6=$2 p7=xx
@end example
NOTE: there is a clash in syntax with the datafile @ref{using} callback
operator. Use `$$n` or `column(n)` to access column n from a datafile inside
a @ref{call}ed datafile plot.
@node clear, evaluate, call, Commands
@section clear
@c ?commands clear
@cindex clear
@cmindex clear
The @ref{clear} command erases the current screen or output device as specified
by @ref{output}. This usually generates a formfeed on hardcopy devices. Use
@ref{terminal} to set the device type.
For some terminals @ref{clear} erases only the portion of the plotting surface
defined by @ref{size}, so for these it can be used in conjunction with @ref{multiplot} to create an inset.
Example:
@example
set multiplot
plot sin(x)
set origin 0.5,0.5
set size 0.4,0.4
clear
plot cos(x)
unset multiplot
@end example
Please see @ref{multiplot}, @ref{size}, and @ref{origin} for details of these
commands.
@node evaluate, exit, clear, Commands
@section evaluate
@c ?commands evaluate
@cindex evaluate
@cmindex evaluate
The @ref{evaluate} command executes the commands given as an argument string.
Newline characters are not allowed within the string.
Syntax:
@example
eval
@end example
This is especially useful for a repetition of similar commands.
Example:
@example
set_label(x, y, text) \
= sprintf("set label '%s' at %f, %f point pt 5", text, x, y)
eval set_label(1., 1., 'one/one')
eval set_label(2., 1., 'two/one')
eval set_label(1., 2., 'one/two')
@end example
Please see @ref{macros} for another way to execute commands
from a string.
@node exit, fit, evaluate, Commands
@section exit
@c ?commands exit
@cindex exit
@cmindex exit
The commands @ref{exit} and @ref{quit}, as well as the END-OF-FILE character (usually
Ctrl-D) terminate input from the current input stream: terminal session, pipe,
and file input (pipe).
If input streams are nested (inherited `load` scripts), then reading will
continue in the parent stream. When the top level stream is closed, the
program itself will exit.
The command `exit gnuplot` will immediately and unconditionally cause gnuplot
to exit even if the input stream is multiply nested. In this case any open
output files may not be completed cleanly. Example of use:
@example
bind "ctrl-x" "unset output; exit gnuplot"
@end example
See help for `batch/interactive` for more details.
@node fit, help, exit, Commands
@section fit
@c ?commands fit
@cindex fit
@cmindex fit
@cindex least-squares
@cindex Marquardt
The @ref{fit} command can fit a user-defined function to a set of data points
(x,y) or (x,y,z), using an implementation of the nonlinear least-squares
(NLLS) Marquardt-Levenberg algorithm. Any user-defined variable occurring in
the function body may serve as a fit parameter, but the return type of the
function must be real.
Syntax:
@example
fit @{[xrange] @{[yrange]@}@} ''
@{datafile-modifiers@}
via '' | @{,,...@}
@end example
Ranges may be specified to temporarily limit the data which is to be fitted;
any out-of-range data points are ignored. The syntax is
@example
[@{dummy_variable=@}@{@}@{:@}],
@end example
analogous to `plot`; see @ref{ranges}.
is any valid `gnuplot` expression, although it is usual to use a
previously user-defined function of the form f(x) or f(x,y).
is treated as in the `plot` command. All the @ref{datafile}
modifiers (@ref{using}, @ref{every},...) except @ref{smooth} and the deprecated @ref{thru}
are applicable to @ref{fit}. See @ref{datafile}.
The default data formats for fitting functions with a single independent
variable, y=f(x), are @{x:@}y or x:y:s; those formats can be changed with
the datafile @ref{using} qualifier. The third item (a column number or an
expression), if present, is interpreted as the standard deviation of the
corresponding y value and is used to compute a weight for the datum, 1/s**2.
Otherwise, all data points are weighted equally, with a weight of one.
Note that if you don't specify a @ref{using} option at all, no y deviations are
read from the datafile even if it does have a third column, so you'll
always get unit weights.
To fit a function with two independent variables, z=f(x,y), the required
format is @ref{using} with four items, x:y:z:s. The complete format must be
given---no default columns are assumed for a missing token. Weights for
each data point are evaluated from 's' as above. If error estimates are
not available, a constant value can be specified as a constant expression
(see @ref{using}), e.g., `using 1:2:3:(1)`.
Multiple datasets may be simultaneously fit with functions of one
independent variable by making y a 'pseudo-variable', e.g., the dataline
number, and fitting as two independent variables. See @ref{multi-branch}.
The `via` qualifier specifies which parameters are to be adjusted, either
directly, or by referencing a parameter file.
Examples:
@example
f(x) = a*x**2 + b*x + c
g(x,y) = a*x**2 + b*y**2 + c*x*y
FIT_LIMIT = 1e-6
fit f(x) 'measured.dat' via 'start.par'
fit f(x) 'measured.dat' using 3:($7-5) via 'start.par'
fit f(x) './data/trash.dat' using 1:2:3 via a, b, c
fit g(x,y) 'surface.dat' using 1:2:3:(1) via a, b, c
@end example
After each iteration step, detailed information about the current state
of the fit is written to the display. The same information about the
initial and final states is written to a log file, "fit.log". This file
is always appended to, so as to not lose any previous fit history; it
should be deleted or renamed as desired. By using the command
`set fit logfile`, the name of the log file can be changed.
If gnuplot was built with this option, and you activated it using `set fit
errorvariables`, the error for each fitted parameter will be stored in
a variable named like the parameter, but with "_err" appended. Thus the
errors can be used as input for further computations.
The fit may be interrupted by pressing Ctrl-C.
After the current iteration completes, you have the option to
(1) stop the fit and accept the current parameter values,
(2) continue the fit, (3) execute a `gnuplot` command as specified by the
environment variable FIT_SCRIPT. The default for FIT_SCRIPT is @ref{replot},
so if you had previously plotted both the data and the fitting function in
one graph, you can display the current state of the fit.
Once @ref{fit} has finished, the @ref{update} command may be used to store final
values in a file for subsequent use as a parameter file. See @ref{update}
for details.
@menu
* adjustable_parameters::
* short_introduction::
* error_estimates::
* control::
* multi-branch::
* starting_values::
* tips::
@end menu
@node adjustable_parameters, short_introduction, fit, fit
@subsection adjustable parameters
@c ?commands fit parameters
@c ?fit parameters
@c ?commands fit adjustable_parameters
@c ?fit adjustable_parameters
@cindex fit_parameters
There are two ways that `via` can specify the parameters to be adjusted,
either directly on the command line or indirectly, by referencing a
parameter file. The two use different means to set initial values.
Adjustable parameters can be specified by a comma-separated list of variable
names after the `via` keyword. Any variable that is not already defined
is created with an initial value of 1.0. However, the fit is more likely
to converge rapidly if the variables have been previously declared with more
appropriate starting values.
In a parameter file, each parameter to be varied and a corresponding initial
value are specified, one per line, in the form
@example
varname = value
@end example
Comments, marked by '#', and blank lines are permissible. The
special form
@example
varname = value # FIXED
@end example
means that the variable is treated as a 'fixed parameter', initialized by the
parameter file, but not adjusted by @ref{fit}. For clarity, it may be useful to
designate variables as fixed parameters so that their values are reported by
@ref{fit}. The keyword `# FIXED` has to appear in exactly this form.
@node short_introduction, error_estimates, adjustable_parameters, fit
@subsection short introduction
@c ?commands fit beginners_guide
@c ?fit beginners_guide
@c ?fit guide
@cindex fitting
@ref{fit} is used to find a set of parameters that 'best' fits your data to your
user-defined function. The fit is judged on the basis of the sum of the
squared differences or 'residuals' (SSR) between the input data points and
the function values, evaluated at the same places. This quantity is often
called 'chisquare' (i.e., the Greek letter chi, to the power of 2). The
algorithm attempts to minimize SSR, or more precisely, WSSR, as the residuals
are 'weighted' by the input data errors (or 1.0) before being squared;
see `fit error_estimates` for details.
That's why it is called 'least-squares fitting'. Let's look at an example
to see what is meant by 'non-linear', but first we had better go over some
terms. Here it is convenient to use z as the dependent variable for
user-defined functions of either one independent variable, z=f(x), or two
independent variables, z=f(x,y). A parameter is a user-defined variable
that @ref{fit} will adjust, i.e., an unknown quantity in the function
declaration. Linearity/non-linearity refers to the relationship of the
dependent variable, z, to the parameters which @ref{fit} is adjusting, not of
z to the independent variables, x and/or y. (To be technical, the
second @{and higher@} derivatives of the fitting function with respect to
the parameters are zero for a linear least-squares problem).
For linear least-squares (LLS), the user-defined function will be a sum of
simple functions, not involving any parameters, each multiplied by one
parameter. NLLS handles more complicated functions in which parameters can
be used in a large number of ways. An example that illustrates the
difference between linear and nonlinear least-squares is the Fourier series.
One member may be written as
@example
z=a*sin(c*x) + b*cos(c*x).
@end example
If a and b are the unknown parameters and c is constant, then estimating
values of the parameters is a linear least-squares problem. However, if
c is an unknown parameter, the problem is nonlinear.
In the linear case, parameter values can be determined by comparatively
simple linear algebra, in one direct step. However LLS is a special case
which is also solved along with more general NLLS problems by the iterative
procedure that `gnuplot` uses. @ref{fit} attempts to find the minimum by doing
a search. Each step (iteration) calculates WSSR with a new set of parameter
values. The Marquardt-Levenberg algorithm selects the parameter values for
the next iteration. The process continues until a preset criterion is met,
either (1) the fit has "converged" (the relative change in WSSR is less than
FIT_LIMIT), or (2) it reaches a preset iteration count limit, FIT_MAXITER
(see @ref{variables}). The fit may also be interrupted
and subsequently halted from the keyboard (see @ref{fit}). The user variable
FIT_CONVERGED contains 1 if the previous fit command terminated due to
convergence; it contains 0 if the previous fit terminated for any other
reason.
Often the function to be fitted will be based on a model (or theory) that
attempts to describe or predict the behaviour of the data. Then @ref{fit} can
be used to find values for the free parameters of the model, to determine
how well the data fits the model, and to estimate an error range for each
parameter. See `fit error_estimates`.
Alternatively, in curve-fitting, functions are selected independent of
a model (on the basis of experience as to which are likely to describe
the trend of the data with the desired resolution and a minimum number
of parameters*functions.) The @ref{fit} solution then provides an analytic
representation of the curve.
However, if all you really want is a smooth curve through your data points,
the @ref{smooth} option to `plot` may be what you've been looking for rather
than @ref{fit}.
@node error_estimates, control, short_introduction, fit
@subsection error estimates
@c ?commands fit error_estimates
@c ?fit error_estimates
@c ?fit errors
In @ref{fit}, the term "error" is used in two different contexts, data error
estimates and parameter error estimates.
Data error estimates are used to calculate the relative weight of each data
point when determining the weighted sum of squared residuals, WSSR or
chisquare. They can affect the parameter estimates, since they determine
how much influence the deviation of each data point from the fitted function
has on the final values. Some of the @ref{fit} output information, including
the parameter error estimates, is more meaningful if accurate data error
estimates have been provided.
The 'statistical overview' describes some of the @ref{fit} output and gives some
background for the 'practical guidelines'.
@menu
* statistical_overview::
* practical_guidelines::
@end menu
@node statistical_overview, practical_guidelines, error_estimates, error_estimates
@subsubsection statistical overview
@c ?commands fit error statistical_overview
@c ?fit error statistical_overview
@cindex statistical_overview
The theory of non-linear least-squares (NLLS) is generally described in terms
of a normal distribution of errors, that is, the input data is assumed to be
a sample from a population having a given mean and a Gaussian (normal)
distribution about the mean with a given standard deviation. For a sample of
sufficiently large size, and knowing the population standard deviation, one
can use the statistics of the chisquare distribution to describe a "goodness
of fit" by looking at the variable often called "chisquare". Here, it is
sufficient to say that a reduced chisquare (chisquare/degrees of freedom,
where degrees of freedom is the number of datapoints less the number of
parameters being fitted) of 1.0 is an indication that the weighted sum of
squared deviations between the fitted function and the data points is the
same as that expected for a random sample from a population characterized by
the function with the current value of the parameters and the given standard
deviations.
If the standard deviation for the population is not constant, as in counting
statistics where variance = counts, then each point should be individually
weighted when comparing the observed sum of deviations and the expected sum
of deviations.
At the conclusion @ref{fit} reports 'stdfit', the standard deviation of the fit,
which is the rms of the residuals, and the variance of the residuals, also
called 'reduced chisquare' when the data points are weighted. The number of
degrees of freedom (the number of data points minus the number of fitted
parameters) is used in these estimates because the parameters used in
calculating the residuals of the datapoints were obtained from the same data.
These values are exported to the variables
@example
FIT_NDF = Number of degrees of freedom
FIT_WSSR = Weighted sum-of-squares residual
FIT_STDFIT = sqrt(WSSR/NDF)
@end example
To estimate confidence levels for the parameters, one can use the minimum
chisquare obtained from the fit and chisquare statistics to determine the
value of chisquare corresponding to the desired confidence level, but
considerably more calculation is required to determine the combinations of
parameters which produce such values.
Rather than determine confidence intervals, @ref{fit} reports parameter error
estimates which are readily obtained from the variance-covariance matrix
after the final iteration. By convention, these estimates are called
"standard errors" or "asymptotic standard errors", since they are calculated
in the same way as the standard errors (standard deviation of each parameter)
of a linear least-squares problem, even though the statistical conditions for
designating the quantity calculated to be a standard deviation are not
generally valid for the NLLS problem. The asymptotic standard errors are
generally over-optimistic and should not be used for determining confidence
levels, but are useful for qualitative purposes.
The final solution also produces a correlation matrix, which gives an
indication of the correlation of parameters in the region of the solution;
if one parameter is changed, increasing chisquare, does changing another
compensate? The main diagonal elements, autocorrelation, are all 1; if
all parameters were independent, all other elements would be nearly 0. Two
variables which completely compensate each other would have an off-diagonal
element of unit magnitude, with a sign depending on whether the relation is
proportional or inversely proportional. The smaller the magnitudes of the
off-diagonal elements, the closer the estimates of the standard deviation
of each parameter would be to the asymptotic standard error.
@node practical_guidelines, , statistical_overview, error_estimates
@subsubsection practical guidelines
@c ?commands fit error practical_guidelines
@c ?fit error practical_guidelines
@cindex practical_guidelines
@cindex guidelines
If you have a basis for assigning weights to each data point, doing so lets
you make use of additional knowledge about your measurements, e.g., take into
account that some points may be more reliable than others. That may affect
the final values of the parameters.
Weighting the data provides a basis for interpreting the additional @ref{fit}
output after the last iteration. Even if you weight each point equally,
estimating an average standard deviation rather than using a weight of 1
makes WSSR a dimensionless variable, as chisquare is by definition.
Each fit iteration will display information which can be used to evaluate
the progress of the fit. (An '*' indicates that it did not find a smaller
WSSR and is trying again.) The 'sum of squares of residuals', also called
'chisquare', is the WSSR between the data and your fitted function; @ref{fit}
has minimized that. At this stage, with weighted data, chisquare is expected
to approach the number of degrees of freedom (data points minus parameters).
The WSSR can be used to calculate the reduced chisquare (WSSR/ndf) or stdfit,
the standard deviation of the fit, sqrt(WSSR/ndf). Both of these are
reported for the final WSSR.
If the data are unweighted, stdfit is the rms value of the deviation of the
data from the fitted function, in user units.
If you supplied valid data errors, the number of data points is large enough,
and the model is correct, the reduced chisquare should be about unity. (For
details, look up the 'chi-squared distribution' in your favourite statistics
reference.) If so, there are additional tests, beyond the scope of this
overview, for determining how well the model fits the data.
A reduced chisquare much larger than 1.0 may be due to incorrect data error
estimates, data errors not normally distributed, systematic measurement
errors, 'outliers', or an incorrect model function. A plot of the residuals,
e.g., `plot 'datafile' using 1:($2-f($1))`, may help to show any systematic
trends. Plotting both the data points and the function may help to suggest
another model.
Similarly, a reduced chisquare less than 1.0 indicates WSSR is less than that
expected for a random sample from the function with normally distributed
errors. The data error estimates may be too large, the statistical
assumptions may not be justified, or the model function may be too general,
fitting fluctuations in a particular sample in addition to the underlying
trends. In the latter case, a simpler function may be more appropriate.
You'll have to get used to both @ref{fit} and the kind of problems you apply it
to before you can relate the standard errors to some more practical estimates
of parameter uncertainties or evaluate the significance of the correlation
matrix.
Note that @ref{fit}, in common with most NLLS implementations, minimizes the
weighted sum of squared distances (y-f(x))**2. It does not provide any means
to account for "errors" in the values of x, only in y. Also, any "outliers"
(data points outside the normal distribution of the model) will have an
exaggerated effect on the solution.
@node control, multi-branch, error_estimates, fit
@subsection control
@c ?commands fit control
@c ?fit control
There are a number of `gnuplot` variables that can be defined to affect
@ref{fit}. Those which can be defined once `gnuplot` is running are listed
under 'control_variables' while those defined before starting `gnuplot`
are listed under 'environment_variables'.
@menu
* control_variables::
* environment_variables::
@end menu
@node control_variables, environment_variables, control, control
@subsubsection control variables
@c ?commands fit control variables
@c ?fit control variables
The default epsilon limit (1e-5) may be changed by declaring a value for
@example
FIT_LIMIT
@end example
When the sum of squared residuals changes between two iteration steps by
a factor less than this number (epsilon), the fit is considered to have
'converged'.
The maximum number of iterations may be limited by declaring a value for
@example
FIT_MAXITER
@end example
A value of 0 (or not defining it at all) means that there is no limit.
If you need even more control about the algorithm, and know the
Marquardt-Levenberg algorithm well, there are some more variables to
influence it. The startup value of `lambda` is normally calculated
automatically from the ML-matrix, but if you want to, you may provide
your own one with
@example
FIT_START_LAMBDA
@end example
Specifying FIT_START_LAMBDA as zero or less will re-enable the automatic
selection. The variable
@example
FIT_LAMBDA_FACTOR
@end example
gives the factor by which `lambda` is increased or decreased whenever
the chi-squared target function increased or decreased significantly.
Setting FIT_LAMBDA_FACTOR to zero re-enables the default factor of
10.0.
Other variables with the FIT_ prefix may be added to @ref{fit}, so it is safer
not to use that prefix for user-defined variables.
The variables FIT_SKIP and FIT_INDEX were used by earlier releases of
`gnuplot` with a 'fit' patch called `gnufit` and are no longer available.
The datafile @ref{every} modifier provides the functionality of FIT_SKIP.
FIT_INDEX was used for multi-branch fitting, but multi-branch fitting of
one independent variable is now done as a pseudo-3D fit in which the
second independent variable and @ref{using} are used to specify the branch.
See @ref{multi-branch}.
@node environment_variables, , control_variables, control
@subsubsection environment variables
@c ?commands fit control environment
@c ?fit control environment
The environment variables must be defined before `gnuplot` is executed; how
to do so depends on your operating system.
@example
FIT_LOG
@end example
changes the name (and/or path) of the file to which the fit log will be
written from the default of "fit.log" in the working directory. The default
value can be overwritten using the command `set fit logfile`.
@example
FIT_SCRIPT
@end example
specifies a command that may be executed after an user interrupt. The default
is @ref{replot}, but a `plot` or `load` command may be useful to display a plot
customized to highlight the progress of the fit.
@node multi-branch, starting_values, control, fit
@subsection multi-branch
@c ?commands fit multi-branch
@c ?fit multi-branch
@cindex multi-branch
@cindex branch
In multi-branch fitting, multiple data sets can be simultaneously fit with
functions of one independent variable having common parameters by minimizing
the total WSSR. The function and parameters (branch) for each data set are
selected by using a 'pseudo-variable', e.g., either the dataline number (a
'column' index of -1) or the datafile index (-2), as the second independent
variable.
Example: Given two exponential decays of the form, z=f(x), each describing
a different data set but having a common decay time, estimate the values of
the parameters. If the datafile has the format x:z:s, then
@example
f(x,y) = (y==0) ? a*exp(-x/tau) : b*exp(-x/tau)
fit f(x,y) 'datafile' using 1:-2:2:3 via a, b, tau
@end example
For a more complicated example, see the file "hexa.fnc" used by the
"fit.dem" demo.
Appropriate weighting may be required since unit weights may cause one
branch to predominate if there is a difference in the scale of the dependent
variable. Fitting each branch separately, using the multi-branch solution
as initial values, may give an indication as to the relative effect of each
branch on the joint solution.
@node starting_values, tips, multi-branch, fit
@subsection starting values
@c ?commands fit starting_values
@c ?fit starting_values
@cindex starting_values
Nonlinear fitting is not guaranteed to converge to the global optimum (the
solution with the smallest sum of squared residuals, SSR), and can get stuck
at a local minimum. The routine has no way to determine that; it is up to
you to judge whether this has happened.
@ref{fit} may, and often will get "lost" if started far from a solution, where
SSR is large and changing slowly as the parameters are varied, or it may
reach a numerically unstable region (e.g., too large a number causing a
floating point overflow) which results in an "undefined value" message
or `gnuplot` halting.
To improve the chances of finding the global optimum, you should set the
starting values at least roughly in the vicinity of the solution, e.g.,
within an order of magnitude, if possible. The closer your starting values
are to the solution, the less chance of stopping at another minimum. One way
to find starting values is to plot data and the fitting function on the same
graph and change parameter values and @ref{replot} until reasonable similarity
is reached. The same plot is also useful to check whether the fit stopped at
a minimum with a poor fit.
Of course, a reasonably good fit is not proof there is not a "better" fit (in
either a statistical sense, characterized by an improved goodness-of-fit
criterion, or a physical sense, with a solution more consistent with the
model.) Depending on the problem, it may be desirable to @ref{fit} with various
sets of starting values, covering a reasonable range for each parameter.
@node tips, , starting_values, fit
@subsection tips
@c ?commands fit tips
@c ?fit tips
@cindex tips
Here are some tips to keep in mind to get the most out of @ref{fit}. They're not
very organized, so you'll have to read them several times until their essence
has sunk in.
The two forms of the `via` argument to @ref{fit} serve two largely distinct
purposes. The `via "file"` form is best used for (possibly unattended) batch
operation, where you just supply the startup values in a file and can later
use @ref{update} to copy the results back into another (or the same) parameter
file.
The `via var1, var2, ...` form is best used interactively, where the command
history mechanism may be used to edit the list of parameters to be fitted or
to supply new startup values for the next try. This is particularly useful
for hard problems, where a direct fit to all parameters at once won't work
without good starting values. To find such, you can iterate several times,
fitting only some of the parameters, until the values are close enough to the
goal that the final fit to all parameters at once will work.
Make sure that there is no mutual dependency among parameters of the function
you are fitting. For example, don't try to fit a*exp(x+b), because
a*exp(x+b)=a*exp(b)*exp(x). Instead, fit either a*exp(x) or exp(x+b).
A technical issue: the parameters must not be too different in magnitude.
The larger the ratio of the largest and the smallest absolute parameter
values, the slower the fit will converge. If the ratio is close to or above
the inverse of the machine floating point precision, it may take next to
forever to converge, or refuse to converge at all. You will have to adapt
your function to avoid this, e.g., replace 'parameter' by '1e9*parameter' in
the function definition, and divide the starting value by 1e9.
If you can write your function as a linear combination of simple functions
weighted by the parameters to be fitted, by all means do so. That helps a
lot, because the problem is no longer nonlinear and should converge with only
a small number of iterations, perhaps just one.
Some prescriptions for analysing data, given in practical experimentation
courses, may have you first fit some functions to your data, perhaps in a
multi-step process of accounting for several aspects of the underlying
theory one by one, and then extract the information you really wanted from
the fitting parameters of those functions. With @ref{fit}, this may often be
done in one step by writing the model function directly in terms of the
desired parameters. Transforming data can also quite often be avoided,
though sometimes at the cost of a more difficult fit problem. If you think
this contradicts the previous paragraph about simplifying the fit function,
you are correct.
A "singular matrix" message indicates that this implementation of the
Marquardt-Levenberg algorithm can't calculate parameter values for the next
iteration. Try different starting values, writing the function in another
form, or a simpler function.
Finally, a nice quote from the manual of another fitting package (fudgit),
that kind of summarizes all these issues: "Nonlinear fitting is an art!"
@node help, history, fit, Commands
@section help
@c ?commands help
@cindex help
@cmindex help
The @ref{help} command displays built-in help. To specify information on a
particular topic use the syntax:
@example
help @{@}
@end example
If is not specified, a short message is printed about `gnuplot`.
After help for the requested topic is given, a menu of subtopics is given;
help for a subtopic may be requested by typing its name, extending the help
request. After that subtopic has been printed, the request may be extended
again or you may go back one level to the previous topic. Eventually, the
`gnuplot` command line will return.
If a question mark (?) is given as the topic, the list of topics currently
available is printed on the screen.
@node history, if, help, Commands
@section history
@c ?commands history
@cindex history
@cmindex history
`history` command lists or saves previous entries in the history of the
command line editing, or executes an entry.
Here you find 'usage by examples':
@example
history # show the complete history
history 5 # show last 5 entries in the history
history quiet 5 # show last 5 entries without entry numbers
history "hist.gp" # write the complete history to file hist.gp
history "hist.gp" append # append the complete history to file hist.gp
history 10 "hist.gp" # write last 10 commands to file hist.gp
history 10 "|head -5 >>diary.gp" # write 5 history commands using pipe
history ?load # show all history entries starting with "load"
history ?"set c" # like above, several words enclosed in quotes
hi !reread # execute last entry starting with "reread"
hist !"set xr" # like above, several words enclosed in quotes
hi !hi # guess yourself :-))
@end example
On systems which support a popen function (Unix), the output of history can be
piped through an external program by starting the file name with a '|', as one
of the above examples demonstrates.
@node if, iteration, history, Commands
@section if
@c ?commands if
@cindex if
@cmindex if
The @ref{if} command allows commands to be executed conditionally.
Syntax:
@example
if () [; else if () ...; else ...]
@end example
will be evaluated. If it is true (non-zero), then the command(s)
of the will be executed. If is false (zero), then
the entire is ignored until the next occurrence of `else`.
Note that use of `;` to allow multiple commands on the same line will
_not_ end the conditionalized commands.
Examples:
@example
pi=3
if (pi!=acos(-1)) print "?Fixing pi!"; pi=acos(-1); print pi
@end example
will display:
@example
?Fixing pi!
3.14159265358979
@end example
but
@example
if (1==2) print "Never see this"; print "Or this either"
@end example
will not display anything.
else:
@example
v=0
v=v+1; if (v%2) print "2" ; else if (v%3) print "3"; else print "fred"
@end example
(repeat the last line repeatedly!)
See @ref{reread} for an example of how @ref{if} and @ref{reread} can be used together to
perform a loop.
@node iteration, load, if, Commands
@section iteration
@cindex iteration
@cmindex iteration
The `plot`, `splot`, `set` and @ref{unset} commands may optionally contain an
iteration clause. This has the effect of executing the basic command
multiple times, each time re-evaluating any expressions that make use of the
iteration control variable. Two forms of iteration clause are currently
supported:
@example
for [intvar = start:end@{:increment@}]
for [stringvar in "A B C D"]
@end example
Examples:
@example
plot for [filename in "A.dat B.dat C.dat"] filename using 1:2 with lines
plot for [basename in "A B C"] basename.".dat" using 1:2 with lines
set for [i = 1:10] style line i lc rgb "blue"
unset for [tag = 100:200] label tag
@end example
See additional documentation for @ref{iteration}.
@node load, lower, iteration, Commands
@section load
@c ?commands load
@cindex load
@cmindex load
The `load` command executes each line of the specified input file as if it
had been typed in interactively. Files created by the @ref{save} command can
later be `load`ed. Any text file containing valid commands can be created
and then executed by the `load` command. Files being `load`ed may themselves
contain `load` or @ref{call} commands. See `comments` for information about
comments in commands. To `load` with arguments, see @ref{call}.
Syntax:
@example
load ""
@end example
The name of the input file must be enclosed in quotes.
The special filename "-" may be used to `load` commands from standard input.
This allows a `gnuplot` command file to accept some commands from standard
input. Please see help for `batch/interactive` for more details.
On some systems which support a popen function (Unix), the load file can be
read from a pipe by starting the file name with a '<'.
Examples:
@example
load 'work.gnu'
load "func.dat"
load "< loadfile_generator.sh"
@end example
The `load` command is performed implicitly on any file names given as
arguments to `gnuplot`. These are loaded in the order specified, and
then `gnuplot` exits.
@node lower, pause, load, Commands
@section lower
@c ?commands lower
@cindex lower
@cmindex lower
Syntax:
@example
lower @{plot_window_nb@}
@end example
The @ref{lower} command lowers (opposite to @ref{raise}) plot window(s) associated
with the interactive terminal of your gnuplot session, i.e. `pm`, `win`, `wxt`
or `x11`. It puts the plot window to bottom in the z-order windows stack of
the window manager of your desktop.
As `x11` and `wxt` support multiple plot windows, then by default they lower
these windows in descending order of most recently created on top to the least
recently created on bottom. If a plot number is supplied as an optional
parameter, only the associated plot window will be lowered if it exists.
The optional parameter is ignored for single plot-window terminals, i.e. `pm`
and `win`.
@node pause, plot, lower, Commands
@section pause
@c ?commands pause
@cindex pause
@cmindex pause
@c ?pause mouse
The @ref{pause} command displays any text associated with the command and then
waits a specified amount of time or until the carriage return is pressed.
@ref{pause} is especially useful in conjunction with `load` files.
Syntax:
@example
pause @{""@}
pause mouse @{@}@{, @} @{""@}
@end example
may be any constant or expression. Choosing -1 will wait until a
carriage return is hit, zero (0) won't pause at all, and a positive number
will wait the specified number of seconds. The time is rounded to an integer
number of seconds if subsecond time resolution is not supported by the given
platform. `pause 0` is synonymous with @ref{print}.
If the current terminal supports mousing, then `pause mouse` will terminate
on either a mouse click or on ctrl-C. For all other terminals, or if mousing
is not active, `pause mouse` is equivalent to `pause -1`.
If one or more end conditions are given after `pause mouse`, then any one of
the conditions will terminate the pause. The possible end conditions are
`keypress`, `button1`, `button2`, `button3`, `close`, and `any`.
If the pause terminates on a keypress, then the ascii value of the key pressed
is returned in MOUSE_KEY. The character itself is returned as a one character
string in MOUSE_CHAR. Hotkeys (bind command) are disabled if keypress is one of
the end conditions. Zooming is disabled if button3 is one of the end
conditions.
In all cases the coordinates of the mouse are returned in variables MOUSE_X,
MOUSE_Y, MOUSE_X2, MOUSE_Y2. See @ref{variables}.
Note: Since @ref{pause} communicates with the operating system rather than the
graphics, it may behave differently with different device drivers (depending
upon how text and graphics are mixed).
Examples:
@example
pause -1 # Wait until a carriage return is hit
pause 3 # Wait three seconds
pause -1 "Hit return to continue"
pause 10 "Isn't this pretty? It's a cubic spline."
pause mouse "Click any mouse button on selected data point"
pause mouse keypress "Type a letter from A-F in the active window"
pause mouse button1,keypress
pause mouse any "Any key or button will terminate"
@end example
The variant "pause mouse key" will resume after any keypress in the active
plot window. If you want to wait for a particular key to be pressed, you can
use a reread loop such as:
@example
print "I will resume after you hit the Tab key in the plot window"
load "wait_for_tab"
@end example
File "wait_for_tab" contains the lines
@example
pause mouse key
if (MOUSE_KEY != 9) reread
@end example
@node plot, print, pause, Commands
@section plot
@c ?commands plot
@cindex plot
@cmindex plot
`plot` is the primary command for drawing plots with `gnuplot`. It creates
plots of functions and data in many, many ways. `plot` is used to draw 2-d
functions and data; `splot` draws 2D projections of 3D surfaces and data.
`plot` and `splot` contain many common features; see `splot` for differences.
Note specifically that although the `binary ` variation does
work for both `plot` and `splot`, there are small differences between these
modes.
Syntax:
@example
plot @{@}
@{@}
@{ | @{"" @{datafile-modifiers@}@}@}
@{axes @} @{@} @{with