File: README

package info (click to toggle)
plotutils 2.0-2
  • links: PTS
  • area: main
  • in suites: hamm
  • size: 5,964 kB
  • ctags: 2,522
  • sloc: ansic: 38,416; sh: 1,853; yacc: 856; makefile: 181; lex: 144
file content (240 lines) | stat: -rw-r--r-- 11,019 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
This is release 2.0 of the GNU plotutils (plotting utilities) package,
including GNU libplot: a function library for 2-D device-independent vector
graphics.

The file INSTALL contains generic instructions dealing with installation of
a GNU package, and the file INSTALL.pkg contains package-specific
installation instructions.  Please read them in full, as well as this file,
before attempting to install the package.

Please send bug reports to <bug-gnu-utils@gnu.org>, and suggestions for
longer-range improvements to both <bug-gnu-utils@gnu.org> and 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.
		To the maximum degree feasible, the output of `graph' will
		appear the same on all display devices.  
	
		Which display device is driven, or output format is
		produced, is specified by the `-T' option.  There are
		effectively six distinct variants of `graph', distinguished
		by the intended display device.

		graph -T X	A variant 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
				distributed under the GNU General Public
				License as part of this package.  See the
				file ./INSTALL.fonts .)

		graph -T ps	A variant that produces EPS (encapsulated
				Postscript) output, which can be printed,
				displayed, or encapsulated in other
				documents.  Any standard page
				size is supported (letter, legal, ANSI
				sizes, ISO sizes such as a4 and a3, etc.)
				The EPS output includes annotations that 
				permit it to be edited with the freeware 
				`idraw' drawing editor, or its successor 
				`drawtool'.  

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

		graph -T hpgl	A variant that produces HP-GL (or by
				default, HP-GL/2) output.  HP-GL is the
				Hewlett-Packard Graphics Language, and
				may be printed out or plotted on a
				Hewlett-Packard LaserJet printer or plotter.
				Also many applications, e.g. CAD applications,
				can import HP-GL or HP-GL/2 figures.
				This variant supports the 45 standard PCL 5
				fonts that are built into many non-Postscript
				printers, such as LaserJets.

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

		graph		The `raw' variant, which produces output in
				GNU graphics metafile format.  This is an
				enhanced version of the traditional plot(5)
				format found on some operating systems.
				The `plot' program (see below) must be used
				to convert this to another format, or
				to drive a display device.

		Of these six variants, `graph -T X', `graph -T tek', and raw
		`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 -T X -x xmin xmax -y ymin ymax

		where `program' generates a stream of data points.)
		
		All variants of `graph' will accept ascii input (the
		default), or unformatted binary input (i.e., a stream of
		floating point numbers or integers), 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 variants of
		graph by using the gnuplot `set output' command.  If you
		are piping to `graph -T X', by repeatedly using the gnuplot
		`set output' command you may easily produce an arbitrarily
		large number of plots in different X windows, each in a
		different style.

	plot.   This is a so-called plot filter, which takes a stream in GNU
		graphics metafile format, and either translates it to
		another format or uses it to drive a display device.

		Since this distribution includes `graph -T X', `graph -T
		ps', `graph -T fig', `graph -T hpgl', and `graph -T tek,
		all of which can drive display devices directly, `plot' is
		only occasionally useful.  It may be used, though, to
		produce graphical output in more than one format at once.
		To do this, you would pipe the output of a
		datapoint-generating program to the raw variant of `graph',
		and then use the `tee' command to direct the output of raw
		`graph', which is in metafile format, to two separate
		invocations of `plot'.
	
		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 text strings, since information on the
		width of strings may not be available.  It is for this
		reason that the raw variant of `graph' is slightly less
		sophisticated about label positioning than the other
		variants.  For most applications, the non-raw variants of
		`graph' are preferred.

		`plot' may also be useful as a post-processor for older
		programs that produce output in the traditional plot(5)
		graphics format.

	libplot.  This is the function library for device-independent 2-D
		vector graphics that the utilities `graph', `plot', and
		`tek2plot' (see below) are based on.  On systems that
		support DLL's (dynamically linked libraries), it is
		installed as a DLL.
		
		The current release of libplot (version 0.0) is a merger of
		what were originally six separate function libraries, one
		for each supported output device.  These function libraries
		(libplotX, libplotps, libplotfig, libplothpgl, libplottek,
		and raw libplot) 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).
		
		libplot includes 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, and libplothpgl supports the 45 standard
		PCL 5 fonts.  In addition, all four, together with
		libplottek, support a full set of traditional Hershey
		vector fonts.  All supported fonts may be arbitrarily
		rotated and scaled.  All fonts, except for symbol and
		dingbat fonts, use the ISO-Latin-1 encoding (a superset of
		ascii; the ISO-Latin-1 support in the Hershey fonts is
		extensive but not quite complete).

	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.
		
	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 variants of `graph'.  If a real-time
		variant of `graph' (e.g. `graph -T X' or `graph -T 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.

	tek2plot.  This is a utility program that emulates a Tektronix 4014
		terminal in the sense that it reads Tektronix commands, and
		drives any of the five sorts of graphic display device
		mentioned above, or (alternatively) produces GNU graphics
		metafile format.  It acts as a filter.

		tek2plot is useful only if you have a legacy 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).  tek2plot
		does an excellent job of emulating the non-interactive
		features of a Tektronix 4014, and although it does not
		support all the features supported by the Tektronix
		emulator in the MS-DOS version of kermit, it can certainly
		parse the output of the gnuplot Tektronix terminal drivers.
		
	double. This is a filter for converting, scaling and cutting
		unformatted (binary) or ascii data streams.  It is still
		under development and is not yet documented.