williams@vu-vlsi.UUCP (01/28/87)
GNUPLOT 1.1: part 5 of 6
This shar file contains the help directory tree, to be used by the
VMS-like help program which has been posted regularly. The files
are also used by the 'vmshelp.csh' script to create 'gnuplot.hlp',
a single help file in VMS help file format. 'gnuplot.hlp' is needed
to create a Gnuplot help library in VMS, and is also used to build the
help tree under MS-DOS with the program BUILDHLP.
If you follow the convention of putting help files in /usr/help on your
system, then you may want to 'su' and 'cd /usr' before executing this script.
------------------------------CUT HERE-------------------------------------
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# help/gnuplot
# This archive created: Tue Jan 27 13:21:39 1987
export PATH; PATH=/bin:$PATH
if test ! -d 'help'
then
echo shar: creating directory "'help'"
mkdir 'help'
fi
if test ! -d 'help/gnuplot'
then
echo shar: creating directory "'help/gnuplot'"
mkdir 'help/gnuplot'
fi
echo shar: entering directory "'help/gnuplot'"
cd 'help/gnuplot'
echo shar: extracting "'.HLP'" '(344 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
GNUPLOT is a command-driven interactive function plotting program. It
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 (;).
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'save.HLP'" '(477 characters)'
if test -f 'save.HLP'
then
echo shar: will not over-write existing file "'save.HLP'"
else
cat << \SHAR_EOF > 'save.HLP'
This command saves either user-defined functions, variables, or both
to the specified file.
Syntax:
save {option} <filename>
Where <option> is either 'functions' or 'variables'. If no option is
used GNUPLOT saves both functions and variables.
'save'd files are written in text format and may be read by the 'load'
command.
The filename must be enclosed in quotes.
Examples:
save "work.gnu"
save functions 'func.dat'
save var 'var.dat'
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'print.HLP'" '(117 characters)'
if test -f 'print.HLP'
then
echo shar: will not over-write existing file "'print.HLP'"
else
cat << \SHAR_EOF > 'print.HLP'
This command prints the value of <expression> to the screen.
Syntax:
print <expression>
See 'expressions'.
SHAR_EOF
fi # end of overwriting check
if test ! -d 'plot'
then
echo shar: creating directory "'plot'"
mkdir 'plot'
fi
echo shar: entering directory "'plot'"
cd 'plot'
echo shar: extracting "'.HLP'" '(548 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
'plot' is the primary command of the program. It plots functions and
data in many, many ways. The full syntax of this command is:
plot {ranges} <function> {style} {, <function> {style}...}
Where <function> is either a mathematical expression or the name of a
data file enclosed in quotes. User-defined functions and variables
may also be defined here.
Curly braces {,} denote optional items.
A 'plot' command can be as simple as
plot sin(x)
or as complex as (!)
plot [t=1:10] [-pi:pi*2] tan(t),"data.1" with lines,t**2 with points
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'style.HLP'" '(856 characters)'
if test -f 'style.HLP'
then
echo shar: will not over-write existing file "'style.HLP'"
else
cat << \SHAR_EOF > 'style.HLP'
Plots may be displayed in one of three styles: 'lines', 'points', or
'impulses'. The 'lines' style connects adjacent points with lines.
The 'points' style displays a small symbol at each point. The
'impulses' style displays a vertical line from the X axis to each
point.
Default styles are chosen with the 'set function style' and
'set data style' commands.
Syntax:
with <style>
Where <style> is one of 'lines', 'points', or 'impulses'. These
keywords may be abbreviated.
Examples:
This plots sin(x) with impulses:
plot sin(x) with impulses
This plots sin(x) with points, cos(x) default:
plot [-9:30] sin(x) w points, cos(x)
This plots tan(x) with the default function style, "data.1" with lines:
plot [] [-2:5] tan(x), "data.1" with l
This plots "leastsq.dat" with impulses:
plot 'leastsq.dat' w i
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'ranges.HLP'" '(1097 characters)'
if test -f 'ranges.HLP'
then
echo shar: will not over-write existing file "'ranges.HLP'"
else
cat << \SHAR_EOF > 'ranges.HLP'
This option specifies the region of the plot which will be displayed.
Ranges may be provided on the 'plot' command line as synonyms for
the 'set xrange' and 'set yrange' commands.
Syntax:
[{dummy-var =} {xmin : xmax}] { [{ymin : ymax}] }
Where dummy-var is the independent variable (the default is 'x',
but this may be changed with the 'set dummy' command) and the min
and max terms can be expressions or constants.
Both the min and max terms are optional. The ':' is also optional
if neither a min nor a max term is specified. This allows '[]' to
be used as a null range specification.
Specifying a Y range turns autoscaling OFF.
Examples:
This uses current ranges:
plot cos(x)
This sets the xrange only:
plot [-10:30] sin(pi*x)/(pi*x)
This is the same, but uses t as the dummy-variable:
plot [t = -10 :30] sin(pi*t)/(pi*t)
This sets both the x and yranges:
plot [-pi:pi] [-3:3] tan(x), 1/x
This sets only the yrange:
plot [] [-2:sin(5)*-8] sin(x)**besj0(x)
This sets xmax and ymin only:
plot [:200] [-pi:] exp(sin(x))
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'data_file.HLP'" '(851 characters)'
if test -f 'data_file.HLP'
then
echo shar: will not over-write existing file "'data_file.HLP'"
else
cat << \SHAR_EOF > 'data_file.HLP'
Discrete data contained in a file can displayed by specifying the
name of the data file (enclosed in quotes) on the 'plot' command
line.
Data files should contain one data point per line. A data point may
be specified either as an X and Y value separated by blank space, or
as just the Y value, in which case the program will use the number
of the coordinate as the X value. Coordinate numbers starts at 0
and are incremented for each data point read. Blank lines and lines
beginning with # will be treated as comments and ignored.
This example compares the data in the file population.dat to a
theoretical curve:
pop(x) = 103*exp((1965-x)/10)
plot [1960:1990] 'population.dat', pop(x)
The file population.dat might contain:
# Gnu population in Antarctica since 1965
1965 103
1970 55
1975 34
1980 24
1985 10
SHAR_EOF
fi # end of overwriting check
echo shar: done with directory "'plot'"
cd ..
echo shar: extracting "'shell.HLP'" '(467 characters)'
if test -f 'shell.HLP'
then
echo shar: will not over-write existing file "'shell.HLP'"
else
cat << \SHAR_EOF > 'shell.HLP'
The 'shell' command spawns an interactive shell. To return to
GNUPLOT, type 'logout' if using VMS, 'exit' or your END-OF-FILE
character if using Unix, or 'exit' if using MS-DOS.
A single shell command may be spawned by preceding it with the !
character ($ if using VMS) at the beginning of a command line.
Control will return immediately to GNUPLOT after this command is
executed. For example,
! dir
prints a directory listing and then returns to GNUPLOT.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'clear.HLP'" '(187 characters)'
if test -f 'clear.HLP'
then
echo shar: will not over-write existing file "'clear.HLP'"
else
cat << \SHAR_EOF > 'clear.HLP'
This command erases the current screen or output device as specified
by 'set output'. This usually generates a formfeed on hardcopy
devices. Use 'set terminal' to set the device type.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'load.HLP'" '(624 characters)'
if test -f 'load.HLP'
then
echo shar: will not over-write existing file "'load.HLP'"
else
cat << \SHAR_EOF > 'load.HLP'
This command executes each line of the specified input file as if it
had been typed in interactively. Files created by the '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' commands. Lines beginning with # (or !
if using VMS) will be treated as comments and ignored.
The 'load' command must be the last command on the line.
Syntax:
load <input-file>
The name of the input file must be enclosed in quotes.
Examples:
load 'work.gnu'
load "func.dat"
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'exit.HLP'" '(172 characters)'
if test -f 'exit.HLP'
then
echo shar: will not over-write existing file "'exit.HLP'"
else
cat << \SHAR_EOF > 'exit.HLP'
'exit', 'quit' and your computer's END-OF-FILE character will exit
GNUPLOT. All these commands will clear the output device (as the
'clear' command does) before exiting.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'quit.HLP'" '(45 characters)'
if test -f 'quit.HLP'
then
echo shar: will not over-write existing file "'quit.HLP'"
else
cat << \SHAR_EOF > 'quit.HLP'
'quit' is a synonym for 'exit'. See 'exit'.
SHAR_EOF
fi # end of overwriting check
if test ! -d 'expressions'
then
echo shar: creating directory "'expressions'"
mkdir 'expressions'
fi
echo shar: entering directory "'expressions'"
cd 'expressions'
echo shar: extracting "'.HLP'" '(432 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
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 may be expressed as the {real,imag}, where <real>
and <imag> must be numerical constants. For example {3,2}
represents 3 + 2i; {0,1} represents 'i' itself.
SHAR_EOF
fi # end of overwriting check
if test ! -d 'functions'
then
echo shar: creating directory "'functions'"
mkdir 'functions'
fi
echo shar: entering directory "'functions'"
cd 'functions'
echo shar: extracting "'.HLP'" '(243 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
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. The sgn()
function is also supported, as in BASIC.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'real.HLP'" '(53 characters)'
if test -f 'real.HLP'
then
echo shar: will not over-write existing file "'real.HLP'"
else
cat << \SHAR_EOF > 'real.HLP'
This function returns the real part of its argument.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'imag.HLP'" '(75 characters)'
if test -f 'imag.HLP'
then
echo shar: will not over-write existing file "'imag.HLP'"
else
cat << \SHAR_EOF > 'imag.HLP'
This function returns the imaginary part of its argument as a real number.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'arg.HLP'" '(67 characters)'
if test -f 'arg.HLP'
then
echo shar: will not over-write existing file "'arg.HLP'"
else
cat << \SHAR_EOF > 'arg.HLP'
This function returns the phase of a complex number, in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'sin.HLP'" '(95 characters)'
if test -f 'sin.HLP'
then
echo shar: will not over-write existing file "'sin.HLP'"
else
cat << \SHAR_EOF > 'sin.HLP'
This function returns the sine of its argument. 'sin' expects its
argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'cos.HLP'" '(97 characters)'
if test -f 'cos.HLP'
then
echo shar: will not over-write existing file "'cos.HLP'"
else
cat << \SHAR_EOF > 'cos.HLP'
This function returns the cosine of its argument. 'cos' expects its
argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'tan.HLP'" '(98 characters)'
if test -f 'tan.HLP'
then
echo shar: will not over-write existing file "'tan.HLP'"
else
cat << \SHAR_EOF > 'tan.HLP'
This function returns the tangent of its argument. 'tan' expects
its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'asin.HLP'" '(106 characters)'
if test -f 'asin.HLP'
then
echo shar: will not over-write existing file "'asin.HLP'"
else
cat << \SHAR_EOF > 'asin.HLP'
This function returns the arc sin (inverse sin) of its argument.
'asin' returns its argument in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'acos.HLP'" '(113 characters)'
if test -f 'acos.HLP'
then
echo shar: will not over-write existing file "'acos.HLP'"
else
cat << \SHAR_EOF > 'acos.HLP'
This function returns the arc cosine (inverse cosine) of its
argument. 'acos' returns its argument in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'atan.HLP'" '(115 characters)'
if test -f 'atan.HLP'
then
echo shar: will not over-write existing file "'atan.HLP'"
else
cat << \SHAR_EOF > 'atan.HLP'
This function returns the arc tangent (inverse tangent) of its
argument. 'atan' returns its argument in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'sinh.HLP'" '(107 characters)'
if test -f 'sinh.HLP'
then
echo shar: will not over-write existing file "'sinh.HLP'"
else
cat << \SHAR_EOF > 'sinh.HLP'
This function returns the hyperbolic sine of its argument. 'sinh'
expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'cosh.HLP'" '(108 characters)'
if test -f 'cosh.HLP'
then
echo shar: will not over-write existing file "'cosh.HLP'"
else
cat << \SHAR_EOF > 'cosh.HLP'
This function returns the hyperbolic cosine of its argument.
'cosh' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'tanh.HLP'" '(109 characters)'
if test -f 'tanh.HLP'
then
echo shar: will not over-write existing file "'tanh.HLP'"
else
cat << \SHAR_EOF > 'tanh.HLP'
This function returns the hyperbolic tangent of its argument.
'tanh' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'int.HLP'" '(80 characters)'
if test -f 'int.HLP'
then
echo shar: will not over-write existing file "'int.HLP'"
else
cat << \SHAR_EOF > 'int.HLP'
This function returns the integer part of its argument, truncated
toward zero.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'abs.HLP'" '(238 characters)'
if test -f 'abs.HLP'
then
echo shar: will not over-write existing file "'abs.HLP'"
else
cat << \SHAR_EOF > 'abs.HLP'
This 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) ].
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'sgn.HLP'" '(187 characters)'
if test -f 'sgn.HLP'
then
echo shar: will not over-write existing file "'sgn.HLP'"
else
cat << \SHAR_EOF > 'sgn.HLP'
This 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.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'sqrt.HLP'" '(55 characters)'
if test -f 'sqrt.HLP'
then
echo shar: will not over-write existing file "'sqrt.HLP'"
else
cat << \SHAR_EOF > 'sqrt.HLP'
This function returns the square root of its argument.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'exp.HLP'" '(105 characters)'
if test -f 'exp.HLP'
then
echo shar: will not over-write existing file "'exp.HLP'"
else
cat << \SHAR_EOF > 'exp.HLP'
This function returns the exponential function of its argument
(e raised to the power of its argument).
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'log.HLP'" '(71 characters)'
if test -f 'log.HLP'
then
echo shar: will not over-write existing file "'log.HLP'"
else
cat << \SHAR_EOF > 'log.HLP'
This function returns the natural logarithm (base e) of its
argument.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'log10.HLP'" '(63 characters)'
if test -f 'log10.HLP'
then
echo shar: will not over-write existing file "'log10.HLP'"
else
cat << \SHAR_EOF > 'log10.HLP'
This function returns the logarithm (base 10) of its argument.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'besj0.HLP'" '(111 characters)'
if test -f 'besj0.HLP'
then
echo shar: will not over-write existing file "'besj0.HLP'"
else
cat << \SHAR_EOF > 'besj0.HLP'
This function returns the j0th Bessel function of its argument.
'besj0' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'besj1.HLP'" '(111 characters)'
if test -f 'besj1.HLP'
then
echo shar: will not over-write existing file "'besj1.HLP'"
else
cat << \SHAR_EOF > 'besj1.HLP'
This function returns the j1st Bessel function of its argument.
'besj1' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'besy0.HLP'" '(111 characters)'
if test -f 'besy0.HLP'
then
echo shar: will not over-write existing file "'besy0.HLP'"
else
cat << \SHAR_EOF > 'besy0.HLP'
This function returns the y0th Bessel function of its argument.
'besy0' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'besy1.HLP'" '(111 characters)'
if test -f 'besy1.HLP'
then
echo shar: will not over-write existing file "'besy1.HLP'"
else
cat << \SHAR_EOF > 'besy1.HLP'
This function returns the y1st Bessel function of its argument.
'besy1' expects its argument to be in radians.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'floor.HLP'" '(182 characters)'
if test -f 'floor.HLP'
then
echo shar: will not over-write existing file "'floor.HLP'"
else
cat << \SHAR_EOF > 'floor.HLP'
This function returns the smallest integer not greater than its
argument. For complex numbers, 'floor' returns the smallest
integer not greater than the real part of its argument.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'ceil.HLP'" '(173 characters)'
if test -f 'ceil.HLP'
then
echo shar: will not over-write existing file "'ceil.HLP'"
else
cat << \SHAR_EOF > 'ceil.HLP'
This function returns the largest integer not less than its
argument. For complex numbers, 'ceil' returns the largest integer
not less than the real part of its argument.
SHAR_EOF
fi # end of overwriting check
echo shar: done with directory "'functions'"
cd ..
if test ! -d 'operators'
then
echo shar: creating directory "'operators'"
mkdir 'operators'
fi
echo shar: entering directory "'operators'"
cd 'operators'
echo shar: extracting "'.HLP'" '(313 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
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.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'binary.HLP'" '(1065 characters)'
if test -f 'binary.HLP'
then
echo shar: will not over-write existing file "'binary.HLP'"
else
cat << \SHAR_EOF > 'binary.HLP'
The following is a list of all the binary operators and their
usages:
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&b * bitwise and
^ a^b * bitwise exclusive or
| a|b * bitwise inclusive or
&& a&&b * logical and
|| a||b * logical or
?: a?b:c * ternary operation
(*) Starred explanations indicate that the operator requires
integer 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.
The ternary operator evaluates its first argument (a). If it is
true (non-zero) the second argument (b) is evaluated and returned,
otherwise the third argument (c) is evaluated and returned.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'unary.HLP'" '(400 characters)'
if test -f 'unary.HLP'
then
echo shar: will not over-write existing file "'unary.HLP'"
else
cat << \SHAR_EOF > 'unary.HLP'
The following is a list of all the unary operators and their
usages:
Symbol Example Explanation
- -a unary minus
~ ~a * one's complement
! !a * logical negation
! a! * factorial
(*) Starred explanations indicate that the operator requires an
integer argument.
The factorial operator returns a real number to allow a greater range.
SHAR_EOF
fi # end of overwriting check
echo shar: done with directory "'operators'"
cd ..
echo shar: done with directory "'expressions'"
cd ..
echo shar: extracting "'start_up.HLP'" '(577 characters)'
if test -f 'start_up.HLP'
then
echo shar: will not over-write existing file "'start_up.HLP'"
else
cat << \SHAR_EOF > 'start_up.HLP'
When GNUPLOT is run, it looks for an initialization file to load.
This file is called '.gnuplot' on Unix systems, and 'GNUPLOT.INI' on
other systems. If this file is not found in the current directory,
the program will look for it in your home directory (under MS-DOS, the
environment variable GNUPLOT should contain the name of this
directory).
If this file is found, GNUPLOT executes the commands in this file.
This is most useful for setting your terminal type and defining any
functions or variables which you use often. The variable 'pi' is
already defined for you.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'user_defined.HLP'" '(572 characters)'
if test -f 'user_defined.HLP'
then
echo shar: will not over-write existing file "'user_defined.HLP'"
else
cat << \SHAR_EOF > 'user_defined.HLP'
You may define your own functions and variables. User-defined
functions and variables may be used anywhere.
User-defined function syntax:
<function-name> ( <dummy-var> ) = <expression>
Where <expression> is defined in terms of <dummy-var>.
User-defined variable syntax:
<variable-name> = <constant-expression>
Examples:
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
The variable 'pi' is already defined for you.
See 'show functions' and 'show variables'.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'replot.HLP'" '(165 characters)'
if test -f 'replot.HLP'
then
echo shar: will not over-write existing file "'replot.HLP'"
else
cat << \SHAR_EOF > 'replot.HLP'
'replot' repeats the last 'plot' command. This can be useful for
viewing a plot with different 'set' options, or when generating the
same plot for several devices.
SHAR_EOF
fi # end of overwriting check
if test ! -d 'set-show'
then
echo shar: creating directory "'set-show'"
mkdir 'set-show'
fi
echo shar: entering directory "'set-show'"
cd 'set-show'
echo shar: extracting "'.HLP'" '(119 characters)'
if test -f '.HLP'
then
echo shar: will not over-write existing file "'.HLP'"
else
cat << \SHAR_EOF > '.HLP'
The 'set' command sets LOTS of options.
The 'show' command shows their settings. 'show all' shows all the
settings.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'autoscale.HLP'" '(269 characters)'
if test -f 'autoscale.HLP'
then
echo shar: will not over-write existing file "'autoscale.HLP'"
else
cat << \SHAR_EOF > 'autoscale.HLP'
If autoscaling is set, the Y axis is automatically scaled to fit the
range of the function or data being plotted. If autoscaling is not
set, the current Y range is used. See 'set yrange'.
Syntax:
set autoscale
set noautoscale
show autoscale
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'output.HLP'" '(314 characters)'
if test -f 'output.HLP'
then
echo shar: will not over-write existing file "'output.HLP'"
else
cat << \SHAR_EOF > 'output.HLP'
By default, plots are displayed to the standard output. The
'set output' command redirects the displays to the specified file or
device.
Syntax:
set output {filename}
show output
The filename must be enclosed in quotes. If the filename is
omitted, output will be sent to the standard output.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'style.HLP'" '(651 characters)'
if test -f 'style.HLP'
then
echo shar: will not over-write existing file "'style.HLP'"
else
cat << \SHAR_EOF > 'style.HLP'
Plots may be displayed in one of three styles: 'lines', 'points', or
'impulses'. The 'lines' style connects adjacent points with lines.
The 'points' style displays a small symbol at each point. The
'impulses' style displays a vertical line from the X axis to each
point.
Default styles are chosen with the 'set function style' and 'set
data style' commands. See 'plot' for information about how to
override the default plotting style for individual functions.
Syntax:
set function style <style>
set data style <style>
show function style
show data style
Where style is either 'lines', 'points', or 'impulses'.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'logscale.HLP'" '(172 characters)'
if test -f 'logscale.HLP'
then
echo shar: will not over-write existing file "'logscale.HLP'"
else
cat << \SHAR_EOF > 'logscale.HLP'
Log scaling may be set on the X and/or Y axis.
Syntax:
set logscale <axes>
set nologscale
show logscale
Where <axes> is either 'x', 'y', or 'xy'.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'variables.HLP'" '(113 characters)'
if test -f 'variables.HLP'
then
echo shar: will not over-write existing file "'variables.HLP'"
else
cat << \SHAR_EOF > 'variables.HLP'
The 'show variables' command lists all user-defined variables and
their values.
Syntax:
show variables
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'functions.HLP'" '(118 characters)'
if test -f 'functions.HLP'
then
echo shar: will not over-write existing file "'functions.HLP'"
else
cat << \SHAR_EOF > 'functions.HLP'
The 'show functions' command lists all user-defined functions and
their definitions.
Syntax:
show functions
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'samples.HLP'" '(400 characters)'
if test -f 'samples.HLP'
then
echo shar: will not over-write existing file "'samples.HLP'"
else
cat << \SHAR_EOF > 'samples.HLP'
The sampling rate of functions may be changed by the 'set samples'
command. By default, sampling is set to 160 points. A higher
sampling rate will produce more accurate plots, but will take
longer. In generating plots, GNUPLOT will use either the sampling
rate set or the resolution of the current output device, whichever
is lower.
Syntax:
set samples <expression>
show samples
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'terminal.HLP'" '(400 characters)'
if test -f 'terminal.HLP'
then
echo shar: will not over-write existing file "'terminal.HLP'"
else
cat << \SHAR_EOF > 'terminal.HLP'
GNUPLOT supports many different graphics devices. Use the 'set
terminal' command to select the type of device for which GNUPLOT
will produce output.
Syntax:
set terminal {terminal-type}
show terminal
If <terminal-type> is omitted, GNUPLOT will list the available
terminal types. <terminal-type> may be abbreviated.
Use 'set output' to redirect this output to a file or device.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'zero.HLP'" '(196 characters)'
if test -f 'zero.HLP'
then
echo shar: will not over-write existing file "'zero.HLP'"
else
cat << \SHAR_EOF > 'zero.HLP'
GNUPLOT will not plot a point if its imaginary part is greater in
magnitude than the 'zero' threshold. The default 'zero' value is
1e-8.
Syntax:
set zero <expression>
show zero
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'xrange.HLP'" '(292 characters)'
if test -f 'xrange.HLP'
then
echo shar: will not over-write existing file "'xrange.HLP'"
else
cat << \SHAR_EOF > 'xrange.HLP'
The 'set xrange' command sets the horizontal range which will be
displayed.
This range may also be specified on the 'plot' command line.
Syntax:
set xrange [{xmin : xmax}]
Where <xmin> and <xmax> terms are expressions or constants.
Both the <xmin> and <xmax> terms are optional.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'yrange.HLP'" '(327 characters)'
if test -f 'yrange.HLP'
then
echo shar: will not over-write existing file "'yrange.HLP'"
else
cat << \SHAR_EOF > 'yrange.HLP'
The 'set yrange' command sets the vertical range which will be
displayed. This command turns autoscaling OFF.
This range may also be specified on the 'plot' command line.
Syntax:
set yrange [{ymin : ymax}]
Where <ymin> and <ymax> terms are expressions or constants.
Both the <ymin> and <ymax> terms are optional.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'dummy.HLP'" '(476 characters)'
if test -f 'dummy.HLP'
then
echo shar: will not over-write existing file "'dummy.HLP'"
else
cat << \SHAR_EOF > 'dummy.HLP'
By default, GNUPLOT assumes that the independent variable is 'x' on
the 'plot' command line. 'x' is called the dummy variable because
it is just a notation to indicate the independent variable. The
'set dummy' command changes this default dummy variable name. For
example, you may find it more convenient to call the dummy variable
't' when plotting time functions:
set dummy t
plot sin(t), cos(t)
Syntax:
set dummy <dummy-var>
show dummy
SHAR_EOF
fi # end of overwriting check
echo shar: done with directory "'set-show'"
cd ..
echo shar: extracting "'help.HLP'" '(298 characters)'
if test -f 'help.HLP'
then
echo shar: will not over-write existing file "'help.HLP'"
else
cat << \SHAR_EOF > 'help.HLP'
The 'help' command displays on-line help. To specify information on a
particular topic use the syntax:
help <topic>
You may exit the help utility and return to GNUPLOT by either pressing
<return> at the 'Topic?' prompt or pressing your computer's END-OF-FILE
character at any help prompt.
SHAR_EOF
fi # end of overwriting check
echo shar: extracting "'substitution.HLP'" '(534 characters)'
if test -f 'substitution.HLP'
then
echo shar: will not over-write existing file "'substitution.HLP'"
else
cat << \SHAR_EOF > 'substitution.HLP'
Command-line substitution is specified by a system command enclosed in
backquotes (`). This command is spawned and the output it produces
replaces the name of the command (and backquotes) on the command line.
Newlines in the output produced by the spawned command are replaced with
blanks.
Command-line substitution can be used anywhere on the GNUPLOT command
line.
Example:
This will run the program 'leastsq' and substitute `leastsq` on the
command line with its output:
f(x) = `leastsq`
or, in VMS
f(x) = `run leastsq`
SHAR_EOF
fi # end of overwriting check
echo shar: done with directory "'help/gnuplot'"
cd ..
# End of shell archive
exit 0