This is release 1.3 of the GNU plotutils (plotting utilities) package,
including GNU libplot: a function library for 2-D device-independent vector
graphics.  The file README discusses the installation process.  Please send
bug reports and feedback on the package (suggestions for improvements,
etc.) to the principal author and current maintainer, Robert Maier
<rsm@math.arizona.edu>.

The contents of the plotutils package are:

	graph.  A full-featured 2-D plotting program, which plots a stream of
		datapoints, in real time if possible.  There is a
		well-chosen set of command-line options for adjusting the
		visual appearance of the plot, labelling axes (with
		expressions that may include subscripts and superscripts,
		and mathematical symbols), choosing marker symbols from
		various fonts, etc.  Multiplotting is supported (a plot may
		include sub-plots, side-by-side or inset).  Filled regions
		are also supported.

		Unlike the well-known plotting program `gnuplot', `graph'
		is device-independent in the sense that its options do not
		depend on the display device the plot is destined for.
		(There are no separate drivers, each with its own options.)
		To the maximum degree feasible, the output of `graph' will
		appear the same on all display devices.  There are five
		versions of `graph', distinguished by the intended display
		device.

		graph-X		A version that pops up an X window on
				an X display, and draws the plot in it.  It
				is most useful on modern (X11R6+) displays,
				which can rotate and scale text
				arbitrarily.  It uses the 35 standard
				Postscript fonts.  (Clones of the 35
				standard fonts, in Type 1 format, have been
				contributed by URW GmbH, and are being
				distributed under the GNU General Public
				License as part of the this package.)

		graph-ps	A version that produces EPS (encapsulated
				Postscript) output, which can be printed,
				displayed, or encapsulated in other
				documents.  The EPS output includes
				annotations that permit it to be edited
				with the `idraw' drawing editor, or its
				successor `drawtool'.

		graph-fig	A version that produces a plot that
				the `xfig' drawing editor can edit.  xfig
				can export the plot in numerous formats,
				such as GIF, X11 bitmap, and EPS.

		graph-tek	A version that produces Tektronix output,
				suitable for viewing, e.g., on an X Windows
				xterm or an MS-DOS kermit doing Tektronix
				emulation.  (This version lacks the
				Postscript fonts of the other versions
				though, like them, it has a complete set of
				vector Hershey fonts.  Also, it does not
				support filling of regions.)

		graph		A `raw' version, which produces output in a
				GNU-enhanced version of the traditional
				plot(5) format found on some systems.
				A plot filter [see below] must be used to 
				drive a display	device.

		Of these five versions, graph-X, graph-tek, and graph are
		real-time.  That means that under some circumstances, they
		act as filters: they read data points from the standard
		input, and plot them as they are read.  For this to happen,
		the abscissa and ordinate ranges of the plot must be
		specified on the command line.  (E.g., the user would do

			program | graph-X -x xmin xmax -y ymin ymax

		where `program' generates a stream of data points.)
		
		All versions of `graph' will accept ascii input (the
		default), or unformatted binary input (i.e., a stream of
		doubles), or input in the `table' format produced by the
		program `gnuplot' (which you may select by specifying the
		`-I g' option).  Gnuplot will produce table-format output
		if you do `set terminal table'; you can pipe gnuplot's
		output to any of the versions of graph by using the gnuplot
		`set output' command.  If you are piping to graph-X, by
		repeatedly using the `set output' command you can easily
		produce an arbitrarily large number of plots in different X
		windows, each in a different style.

	plot filters.  There are five of them: plot2X, plot2ps,
		plot2fig, plot2tek, and plot2plot.  Each of the first four
		takes a stream in GNU-enhanced plot(5) format, and either
		translates it to another format or uses it to drive a
		display device.  (plot2plot is used to translate among
		versions of plot(5) format.)

		Since this distribution includes `graph-X', `graph-ps',
		`graph-fig, and `graph-fig', all of which can drive display
		devices directly, these filters are only occasionally
		useful.  They can be used, though, to produce output in
		more than one format at once.  To do this, one would pipe
		the output of a datapoint-generating program to the raw
		version of `graph', and then use the `tee' command to
		direct the output of raw `graph', which is in a GNU-enhanced
		version of the traditional plot(5) format, to two different 
		plot filters.
	
		Note that introducing an intermediate textual
		representation between graphics function calls and a
		display device necessarily forces communication to be
		one-way.  This is a handicap when positioning multiple text
		strings, since no precise information on the width of
		strings is available.  It is for this reason that the raw
		version of `graph' is slightly less sophisticated about
		label positioning than the other four versions.  (It does
		not rotate ordinate labels, in particular.)  The use of the
		non-raw versions of `graph' is recommended.

		The plot filters may also be useful as post-processors for
		older programs that produce output in the traditional
		plot(5) format.  The GNU-enhanced version of plot(5) format
		is backward compatible.

	GNU libplot.  This is actually five separate function libraries.
		These function libraries (libplotX, libplotps,
		libplotfig, libplottek, and raw libplot) are the libraries
		that the five versions of `graph', and the five plot
		filters and the five tek2plot filters [see below], are
		linked with.  They generate 2-D vector graphics output in a
		highly device-independent manner.  They include functions
		to draw lines and polylines, circles and ellipses, circular
		and elliptic arcs, text (``labels''), and marker symbols.
		Arbitrary affine coordinate transformations from 
		user coordinates to normalized device coordinates are
		supported, as is the notion of a stack of drawing 
		states (i.e., a stack of graphics contexts).  There is
		support for color (both pen color and fill color for
		objects).
		
		The plot libraries include extensive support for accurate
		sizing and positioning of text.  This includes the
		placement of subscripts and superscripts.  For fonts,
		libplotX, libplotps, and libplotfig all support the 35
		standard Postscript fonts.  In addition, all three,
		together with libplottek, support a full set of traditional
		Hershey vector fonts.  All supported fonts can be
		arbitrarily rotated and scaled.  All fonts, except for
		symbol and dingbat fonts, use the ISO-Latin-1 encoding (a
		superset of ascii; the Hershey fonts support ISO-Latin-1
		only partially).

	spline. This program does spline interpolation of input data.
		That is, it takes a file of datapoints, and interpolates
		between them to produce an interpolated segment of the
		input data.  It acts as a filter, though usually not as a
		real-time one (in the most common mode of operation, the
		entire input must be read before any data points are
		output).

		The output spline is normally a cubic spline, but if a
		`tension' parameter is set to a nonzero value, the output
		spline will be a so-called spline under tension.  There is
		also support for doing cubic Bessel interpolation.  If this
		option is selected, `spline' acts as a true real-time
		filter, since cubic Bessel interpolation is local rather
		than global.
		
	double. This is a filter for converting, scaling and cutting
		unformatted (binary) or ascii double precision data
		streams.  It is still under development.
	
	ode.    This interactive program supplements the computation
		engine of `gnuplot', which will compute and plot functions,
		by providing the ability to integrate systems of ordinary
		differential equations (ODE's).  ode will solve the initial
		value problem for one or more first-order ODE's, when
		provided with an explicit expression for each equation.
		ode parses the set of equations and the set of initial
		conditions, which may be typed in manually or read from a
		file, and then produces a stream of data points that may be
		piped to any of the versions of `graph'.  If a real-time
		version of `graph' (e.g. graph-X or graph-tek) is used, the
		numerical solution will be displayed in real time, as it is
		generated.

		One application (certainly not the only one!) of ode is to
		graph the indefinite integrals of the sorts of function
		that gnuplot can graph.  All the primitive real-valued
		functions that are built into gnuplot are built into ode.

		For sample ode input files, see the ./ode-examples
		directory.

The following items are not made by default; to make and install them,
you have to do `cd tek2plot' and then `make' and `make install'.

	tek2plot filters.  These emulate a Tektronix 4014 terminal in the
		sense that they read Tektronix commands, and drive any of
		the four sorts of graphic display device mentioned above,
		or (alternatively) produce a GNU-enhanced version of the
		traditional plot(5) format.  There are five filters: 
		tek2X, tek2ps, tek2fig, tek2tek (redundant), and raw
		tek2plot.  There is only one basic program, but it is 
		linked with the five different versions of libplot.

		These filters are useful only if you have a program that is
		intended to drive a Tektronix terminal or emulator.  The
		directory ./tek2plot/teksamples includes a few files in
		Tektronix format which you may experiment with.  You may
		also experiment by piping the output of `gnuplot', if you
		have configured it to produce Tektronix-format plots, to
		these filters (the gnuplot terminal types `kc_tek40xx',
		`km_tek40xx', `tek40xx', and `vttek' all work).  The
		tek2plot filters do a good job of emulating the
		non-interactive features of a Tektronix 4014, and although
		they do not fully emulate the kermit Tektronix emulator,
		they can certainly parse the output of the gnuplot 
		Tektronix-type terminal drivers.
