home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
DP Tool Club 16
/
CD_ASCQ_16_0994.iso
/
maj
/
2199
/
graphica.fil
< prev
next >
Wrap
Text File
|
1994-07-09
|
173KB
|
4,766 lines
≡about
≡
┌──────────────────────────────────────────────────────────────────────┐
│ G R A P H I C A │
└──────────────────────────────────────────────────────────────────────┘
Graphica is a command-driven interactive/batch graphics program for
making presentation quality graphs on a computer. This two-dimensional
data plotting system is designed specifically for scientific and
engineering applications. Graphica is easy to use, powerful and it
runs on personal computers, mainframes and workstations. With Graphica,
you can:
o plot data or functions
o evaluate and plot mathematical expressions
o fit splines, polynomials and smooth data
o display and print graphs on hardcopy devices
o export graphs in HPGL, PostScript and other output formats
o draw text in 11 different fonts, including roman, greek,
cyrillic and gothic
o draw hundreds of specialized symbols
o get online help
≡arc
≡noarc
Purpose:
Draw an Arc
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ arc {tag} {center at <x>,<y>} │
│ {radius <value>} │
│ {start/end angle <value>} │
│ noarc {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws an arc with the given radius starting at angle
<start angle> and ending at angle <end angle>.
Entering 'arc' by itself simply shows the currently defined arcs.
Examples:
» arc radius 2.0 center at 3.0 4.0 start angle 10 end 45
» arc center at 2 1 start 23 end 90
» noarc 4
Also see ARROW, CIRCLE, LABEL, LEGEND, LINE, RECTANGLE and SECTOR.
≡arrow
≡noarrow
Purpose:
Plot an Arrow at the End of a Line
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ arrow {tag} {from sx,sy} {to ex,ey} {len} {ang} {type (1-5)} │
│ noarrow {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'arrow' command is used to draw arrows. All positions (x,y) default
to 0,0. The x and y values are real numbers. These values can be either
in paper (inches) or graph coordinate system (mapped) units
depending on the status of the location flag (see the LOCATION command).
The tag is an integer that may be used to identify a given arrow.
If no tag is given, the lowest unused tag value is assigned
automatically. This tag can be used to delete or change a specific
arrow. To change any attribute of an existing arrow, use the arrow
command with the appropriate tag, and specify the parts of the arrow
to be changed.
An optional arrow type may be specified. The default arrow type is
3 or full. The available arrow types are:
1 single wing
2 single wing with a back line
3 full
4 full with a half dimension line
5 full with a dimension line
The arrowhead length and width are 20% and 6% of the total arrow length.
If the arrowhead length is less than 1/8", it will remain at 1/8"
regardless of the total arrow length.
Entering 'arrows' by itself simply shows the currently defined arrows.
Examples:
to set an arrow pointing from the origin to (1,2) use:
» arrow to 1.0,2.0
to set an arrow from (-10,4) to (-5,5), and tag the arrow number 3, use:
» arrow 3 from -10,4 to -5,5
to change the preceding arrow begin at 1.1,1.3, use:
» arrow 3 from 1.1,1.3
to delete arrow number 2 use:
» noarrow 2
to delete all arrows use:
» noarrow
Also See:
CIRCLE, LINE and RECTANGLE.
≡audit
Purpose:
Set Command Trace
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ audit {'filename'} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command makes a copy of all your input commands into the given
filename. You may later use it as a 'load' or 'input' file.
Examples:
» audit 'trace.dat'
» audit
in the latter case, a file called 'graphica.odt' will contain a trace
of anything entered at the command line after entering 'audit'.
≡autoscale
≡noautoscale
Purpose:
Set Axis Autoscaling
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ autoscale {x,y,y2,x2} │
│ noautoscale │
└──────────────────────────────────────────────────────────────────────┘
Description:
Frequently, it is difficult for the user to select suitable axis limits
and step sizes, especially if the data being plotted varies greatly from
one execution of the program to the next. For this reason Graphica
provides automatic axis scaling for all axes as the default.
The autoscale command sets the autoscaling feature for an axis. If an
axis is not autoscaled, the default or current map is used when data is
plotted.
Entering 'autoscale' by itself simply shows the currently defined scaling.
Examples:
» autoscale x
» noautoscale
Another example. Suppose you have a data file with two columns of data,
x and y but don't know their ranges. You could do the following:
» data 'mydata.dat'
» draw data
» plot x y
and determine how the data looks. The axes are autoscaled. Then you could
say,
» noaxes
» map x 0 100 y 30 200
where the mapped range would be your own values and then,
» draw x y
would draw the axes with the desired mapped range.
≡noaxes
≡axes
Purpose:
Show, Delete All Axes
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ axes │
│ noaxes │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'noaxes' command will delete any previously specified axes, so the
effect is as if the axes had never been drawn. It is very useful for one
important reason: Graphica maintains a list in memory of all the axes that
have been drawn on the same page. For example, if you had 2 graphs on one
page and needed to get a hardcopy, Graphica would have to keep track of
where everything is so that it could give you an exact reproduction on
paper of what you had on your screen. The 'noaxes' command effectively
wipes out all traces of previously drawn axes and lets you start anew.
Entering 'axes' by itself simply shows the currently defined axes.
Examples:
» axes
» noaxes
≡background
Purpose:
Specify Background Color
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ background {color} {integer}/<name> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Sets the background color. See the PEN COLOR command for more
details about the colors available to use with this command.
Entering 'background' by itself simply shows the currently defined
background color. The default background color is 'black'.
Examples:
» background 3
» back red
≡beep
≡nobeep
Purpose:
Toggle Beep On and Off
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ beep │
│ nobeep │
└──────────────────────────────────────────────────────────────────────┘
Description:
These two commands are used to toggle Graphica beeps on and off.
The default is on.
Examples:
» beep
activates the beep when the screen has been drawn or when there is an error.
» nobeep
turns beeping off.
≡character
≡fonts
≡character fonts
Purpose:
Set Character Font and Attributes
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ character {gap,ratio,size,slant} <value> │
│ character {font} <integer> │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command sets character attributes such as the font type,
character gap, ratio, size and slant.
A font is a collection of characters with a unified design. The 'font'
command defines the font style for characters. Characters may be
hardware or software generated. The default font style is 1 which is a
software generated character. The software generated character fonts are
based on a database originally created by Dr. A.V. Hershey while working at
the U.S. National Bureau of Standards. They have been reorganized and
classified into several groups following the ASCII set. The font sets
currently implemented are:
font 1 = simplex roman
font 2 = simplex greek
font 3 = complex roman
font 4 = complex greek
font 5 = complex cyrillic
and for registered users ten more:
font 6 = simplex script
font 7 = complex script
font 8 = triplex roman
font 9 = gothic german
font 10 = gothic english
font 11 = gothic italian
font 12 = symbols I
font 13 = symbols II
font 14 = symbols II
font 15 = symbols IV
Entering 'character' by itself simply shows the currently defined
character specs.
The font files have to be somewhere in your DOS path. Alternatively,
you may specify an environment variable called GRAPFONT containing the
font directory. For example, if your fonts are in C:\GRAPHICA\FONTS,
then you would specify,
SET GRAPFONT=C:\GRAPHICA\FONTS
somewhere in your autoexec.bat file or in a batch file just before
running Graphica. (Font files have the names YY**.BIN where ** is a
number from 01 to 15.)
Extended character sets:
------------------------
Fonts 1 and 3 (simplex roman and complex roman) include "extended
ascii" characters. This means that you can draw some more characters
without changing the font. For example, A with an "umlaut" (two dots)
is ASCII 143, a with a circle on top of it is 134, etc. The extended
set is by no means complete yet but I'm getting there. It maps the
MSDOS Multilingual (Latin I) code page set from ASCII 127 to 212 (so
far, with a few missing symbols). To use characters from the extended
set, lookup TEXT in this help system.
Examples:
» character size 0.15 ratio 0.6
» char gap 0.2 slant -10
» character font 2
» font 3
This last command specifies a font of complex roman style.
Also see CHARACTER FONT, CHARACTER GAP, CHARACTER RATIO, CHARACTER SIZE,
CHARACTER SLANT, SUBSCRIPT, SUPERSCRIPT, TEXT and ENVIRONMENT.
≡character gap
≡gap
Purpose:
Change the Character Gap
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ character gap <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The character gap attribute defines the spacing between adjacent
characters in a text string, in the direction of the character path.
The character gap is defined as a fraction of the average character box
size. The default gap of 0.0 implies that adjacent character boxes are
to be abutting. A gap of 1.0 implies that a gap, equivalent to the
size of the average character box, is to be inserted between adjacent
characters along the path. A gap of -0.5 implies that character boxes
are to partially overlap.
Example:
» character gap 1.0
≡character ratio
≡ratio
Purpose:
Change the Character Ratio
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ character ratio <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Specifies the ratio of the width of the character to its height. The
default character ratio is 1.0.
Example:
» character ratio 0.8
≡character size
Purpose:
Change the Character Size
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ character size <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The character size attribute defines the vertical size of the
characters in default units (in, cm, mm). Graphica sets the default
character size of all strings and labels to 0.17 in.
Example:
» character size 0.2
≡character slant
≡slant
Purpose:
Set the Character Slant
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ character slant <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Specifies the number of degrees the characters tilt from the vertical.
The sign convention for the direction of rotation is as follows:
+ clockwise
- counterclockwise
The default character slant is 0.0 degrees.
Example:
» character slant 25
≡cd
Purpose:
Change the Working Directory
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ cd <directory-name> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'cd' command changes the working directory to the directory specified
by <directory-name>.
Examples:
» cd c:\work
» cd ..
» cd c:\work\examples
≡circle
≡nocircle
Purpose:
Draw a Circle
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ circle {tag} {center at <x>,<y>} {radius <value>} {filled/nofill} │
│ nocircle {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws a circle with the given radius in user default
units at the given position (also in user default units).
Entering 'circles' by itself simply shows the currently defined circles.
Examples:
» circle radius 2.0 center at 3.0 4.0
» circle 4 center at 2 1 filled
» nocircle 3
Also see ARC, ARROW, LABEL, LEGEND, LINE, RECTANGLE and SECTOR.
≡clc
Purpose:
Clear Text Screen
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ clc │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'clc' command erases the current text screen.
Example:
» clc
See also CLEAR and DEFAULT.
≡clear
Purpose:
Erase Output Device
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ clear │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'clear' command erases the current graphics screen or output device
as specified by output. It also resets all internal flags to the default
state found when entering Graphica, i.e. no axes, no frame, default map,
etc. This usually generates a formfeed on hardcopy devices.
Example:
» clear
See also CLC and DEFAULT.
≡column
Purpose:
Assign Data Columns to Axes
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ column <integer> {is} {x,y,y2,x2} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This powerful command allows the assignment of any data column read
from a user file to a certain axis.
Entering 'columns' by itself simply shows the currently defined columns.
Examples:
» column 3 y2
» column 2 is x 1 is y
assigns column 3 of a data file to the x-axis and column 1 to the y-axis.
Then plot x y add points will generate a graph of column 3 versus column 1.
Also see PLOT.
≡comment
Purpose:
Ignore the Rest of a Line
┌──────────────────────────────────────────────────────────────────────┐
│ comments │
└──────────────────────────────────────────────────────────────────────┘
Comments are supported as follows: a '#' (hatch) may appear in most
places in a line and Graphica will ignore the rest of the line. It
will not have this effect inside quotes or inside numbers (including
complex numbers).
Examples:
» # test file
» echo # echo all commands from here on out
» # map axes
» map x 0 10 y 0 10 # this is the map command
≡contributions
┌──────────────────────────────────────────────────────────────────────┐
│ GRAPHICA Copyright (c) 1992-94 Antonio Montes. All rights reserved. │
└──────────────────────────────────────────────────────────────────────┘
GRAPHICA is shareware and as such is NOT FREE for use in a business,
commercial, government, or institutional environment. Registration
of GRAPHICA for personal (not at the office) use is optional. If you
like this program and find it useful, you can support its continued
development by sending me a contribution of NFL 55 (dutch guilders)
or US$30 (US dollars). Your financial support is needed to encourage
further improvements to GRAPHICA. Business, commercial, government,
or institutional GRAPHICA users must register GRAPHICA after a 30-day
evaluation period. If you want to see additional features in GRAPHICA,
please send in a contribution. Feel free to contact me for any reason.
┌──────────────────────────────────────────────────────────────────────┐
│ Antonio Montes Internet address: tony@amontes.oss.nl │
│ Postbus 13 CompuServe ID: 71031,1162 │
│ 2350 AA Leiderdorp │
│ The Netherlands │
└──────────────────────────────────────────────────────────────────────┘
≡data
≡file
Purpose:
Read Data from Terminal or a File
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ data {from} {file} {'filename'} {autox} │
│ x(1) y(1) │
│ x(2) y(2) │
│ x(3) y(3) │
│ . . │
│ x(n) y(n) │
│ end │
└──────────────────────────────────────────────────────────────────────┘
Description:
Discrete data contained in a file can displayed by specifying the name
of a data file (enclosed in quotes) on the plot command line. Using the
'data' command simply reads in the data from a file, without plotting it.
If the data to be plotted is on a data file already, then the command
'data {from} {file}' opens the data file and reads data points.
Data files may contain one or more data points per line. If more than
one data point is encountered on a line, the data points in a given
column are referred to as columns. If just one value is given on a
line, the program will use the number of the coordinate as the x value.
Coordinate numbers start at 1 and are incremented for each data point
read.
Lines beginning with # will be treated as comments and ignored.
Graphica will also ignore anything within two double quotes before
data on a line.
Numbers can be separated by a comma or one or more blanks (free format).
There is no limit to the number of data points possible (well, until
memory is exhausted.) Optionally, data pairs read interactively can be
put on a single input line. You can't input multiple columns of data
interactively, just two columns.
In data files, up to 20 columns of data can be read in on a line. These
data can in turn be assigned to different axes with the COLUMN command
later on.
Specifying 'autox' will result in the automatic assignment of the x
values starting from 1. In other words, you may read in one or more
columns of y data only and Graphica will assign the x values for you.
It is possible to have several sets of data one after another in the
same data file. Simply separate the sets with blank lines: Graphica
will read each set in sequence and plot the curves one after another.
This way you won't need a bunch of data filenames in one script file:
just put all the data in one data file separated by blank lines.
Also see COLUMN and MISSING.
Examples:
Interactive data input:
» data # interactive data input only
» 1.0,10.0 2.0,20.0 3.0,30.0 4.0,40.0 5.0,50.0
» end
Data file input:
» data 'gel3.dat'
» data file 'comfil'
» data 'test.dat' autox
In this last example, if 'test.dat' contained only one column of data
(the y values), x would be assigned automatically by Graphica.
≡default
Purpose:
Reset Parameter Settings to a Default State
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ default <parameter> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'default' command resets parameter settings to their default value.
The available parameters are:
all
character
division
map
tic
unit
Examples:
» default all
resets all the above parameters to their default value. Graphica does
the equivalent of 'default all' at startup or when a 'paper size'
command is given.
» def map
resets all axes mapping to the default state.
Also see CLEAR.
≡del
≡delete
≡rm
Purpose:
Delete a File
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ del <file> │
│ rm <file> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'del' command deletes a file. Pathnames, wildcards, and drive
designators may be used in the usual way for your operating system.
Other operating system commands can be issued using the $ character
followed by a command. 'rm' is the equivalent UNIX command.
Examples:
» del script.plt
deletes the ASCII file script.plt.
» del foo
deletes the ASCII file foo.
Also see DIR, SHELL, TYPE and WHAT.
≡digitize
Purpose:
Establish an x-y Position
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ digitize │
└──────────────────────────────────────────────────────────────────────┘
Description:
Establish the (x,y) coordinates of a point on the plot. This position is
relative to the graphic origin (0,0), the lower left hand corner of the
paper on which the plot appears, and is given is the default unit system.
If the mouse driver is loaded and your graphics card supports it (I
can only make it work with VGA), a crosshair will appear and you may
move it around by moving your mouse. By pressing any mouse button the
point will be digitized. If the mouse can't be used, the keyboard
(up/down/left/right) arrow keys will let you move a cross-hair around
until you hit the enter (or return) key. Pressing H or D will half or
double the cursor step size.
Example:
» digitize
will give you the coordinates of the point on which the cursor was on the
plot before you pressed return, in inches, cm or mm.
≡dir
≡ls
Purpose:
List Files
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ dir <file> │
│ ls <file> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'dir' command lists the files and subdirectories in a directory.
Pathnames, wildcards, and drive designators may be used in the usual way
for your operating system. Other operating system commands can be issued
using the $ character on the very first position of a line followed by a
command. 'ls' is the equivalent UNIX command.
Examples:
» dir
lists all files in the current directory.
» dir *.plt
lists all files with an extension of .plt in the current directory.
Also see DEL, SHELL, TYPE and WHAT.
≡display
≡nodisplay
Purpose:
Toggle Mouse/Cursor Location
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ display │
│ nodisplay │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command shuts off the display of the mouse position on DOS systems
at the bottom right corner of the screen in graphics mode.
≡divisions
Purpose:
Set Number of Major and Minor Axis Divisions
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ divisions {x,y,y2,x2} <major> <minor> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica draws a tic at each axis value (major tic) and other tic marks
in between (minor tics).
The 'divisions' command determines the number of major and minor tic
marks. These two numbers must be integers. Major and minor tic marks
are one less than the total number of divisions for a particular axis.
For example, if the x-axis range is 0 to 25, a good selection for major
divisions would be 5. The major tic marks will appear at 5, 10, 15,
and 20. 5 could be chosen as the number of minor divisions. This
results in four minor tic marks between two major ones. The default
divisions are 5 and 2.
Entering 'divisions' by itself simply shows the currently defined divisions.
Example:
» divisions x 6,3 y 4,2
≡draw
Purpose:
Draw an Axis
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ draw {x,y,y2,x2} {mask} {reflect} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Draws the specified axis with the given range, tic size and number of
divisions. The key words 'x,x2,y,y2' may be followed by two optional
key words, 'mask' and/or 'reflect'. If 'mask' is specified, that axis
is drawn with the major and minor tic marks but with no numbers or
label. If the 'reflect' option is used, a mirror image of that axis is
drawn. The 'reflect' option doesn't apply when ORIGIN is used.
Example:
» draw x reflect y reflect
draws the x and y axes with opposite mirror images.
Note: You may draw more than one axis of the same kind by suitably
changing the subplot area.
≡dummy
Purpose:
Specify Dummy Variables
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ dummy <dummy-var-1> <dummy-var-2> │
└──────────────────────────────────────────────────────────────────────┘
Description:
By default, Graphica assumes that the independent variable for the
'plot' command line is 'x'. These variables are called the dummy variable
because it is just a notation to indicate the independent variable. The
'dummy' command changes the default dummy variable names. For example,
you may find it more convenient to call the dummy variable 't' when
plotting time functions.
Entering 'dummy' by itself simply shows the currently defined dummy
variables.
Examples:
» dummy t
» dummy u,v
See also FUNCTIONS and WHO.
≡dump
Purpose:
Generate Hardcopy Output
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ dump {device-type} {'filename'} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Generates hardcopy output into a file. The available device types are:
epson, epsf, gif, hpgl, hpgl2, lj2, lj4, pcx, pic,
postscript and tif
If the filename is omitted, Graphica will use a default filename of the
form 'graphica.xxx' where xxx is one of:
prn, eps, gif, hpg, lj2, lj4, pcx, pic, ps, tif
depending on the chosen device type. If the device type is missing and
you have defined the environment variable GRAPDUMP, then this device will
be used. A device type specified on the command line overrides any device
type previously specified in GRAPDUMP. You will get an error message if
Graphica can't find a device type somewhere (either in the environment or
on the command line.)
If you wish to dump directly to a device, there are two options. First,
you can dump to a file and then use the OS command $ to perform a copy
to a printer or plotter. The second option is not to use the dump command,
but to use the OUTPUT command and then do a SHOW. Both achieve the same
purpose. Let's illustrate both on the DOS version:
» dump postscript
» $copy graphica.ps prn
or
» (do some graphics on screen)
» output prn
» term postscript
» show
This last example would 'redraw' everything in PostScript to the printer
specified by prn.
Examples:
» dump hpgl 'plotter.dat'
generates a file called plotter.dat containing HPGL commands. You may
send this file directly to an HP plotter or import it into another
program which accepts HPGL commands, such as WordPerfect, Ventura
Publisher, etc.
» dump hpgl
does the same thing except it dumps the output to 'graphica.hpg'.
» dump 'plotter.dat' hpgl
same effect as the first example.
» dump
In this case, if GRAPDUMP=post, a postscript file will be generated,
but you will get an error message otherwise.
» dump post "graph.ps" color
generates a PostScript file called 'graph.ps' for color printers.
On DOS systems,
» dump epson
generates a binary file called 'graphica.prn' which you may send to an
Epson-compatible printer (after you're out of Graphica or by 'shelling'
out to DOS) by typing:
C:\>copy/b graphica.prn lpt1:
The resolution of this plot is 512 x 768 pixels on a 9-pin dot-matrix
printer.
Also see ENVIRONMENT, HPGL, LASERJET, OUTPUT, TERMINAL and POSTSCRIPT.
≡echo
≡noecho
Purpose:
Echo Typed Commands
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ echo │
│ noecho │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'echo' command causes all input typed at the terminal or picked up
from a load file to be displayed at the terminal. This is useful with
a load file because progress can be monitored. The default is 'noecho.'
Examples:
» echo
switches echoing on
» noecho
switches echoing off.
≡quit
≡exit
Purpose:
Exit Graphica
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ exit │
│ quit │
└──────────────────────────────────────────────────────────────────────┘
Description:
The commands 'exit' and 'quit' will terminate Graphica. These commands
will clear the output device (as the clear command does) before exiting.
If this command is used in a script file, program execution halts
immediately. Do not use this command until you really want to exit the
program.
Example:
» exit
and you will be back at the command line prompt.
≡exponent
≡noexponent
Purpose:
Select Between Fixed or Exponential Format in Log Labels
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ exponent │
│ noexponent │
└──────────────────────────────────────────────────────────────────────┘
Description:
Use this option to select either a fixed or exponential format for
logarithmic axis tic mark labels.
Exponential format is displayed as the number 10 with an exponent. For
example, the value 0.001 will be displayed as 10 to the power -3 on a log
axis with exponential format.
Example:
» exponent
Also see FORMAT.
≡format
Purpose:
Specify Number of Decimal Places in an Axis Label
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ format {x,y,y2,x2} <integer> │
│ format {x,y,y2,x2} ({"<lab>"} <pos> {, {"<lab>"} <pos>}...) │
│ format {log} n │
│ format {long} {short} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The main 'format' command controls the format of numbers plotted next
to the major tic marks. The parameter in angle brackets indicates the
number of digits drawn after the decimal point. A -1 or 0 causes the
numbers to be displayed in integer format. The default value for the
number of digits to the right of the decimal point is 1.
The ("<label>" <pos>, ...) format allows non-numeric tic labels. Each
set of tics can have an optional label. The label is a string enclosed
by quotes, such as "hello". The label may even be empty. You have to
include the ( and ) for the non-numeric tic labels to work. Of course,
the corresponding axis will have to be mapped properly for user-defined
labels to work. That is, if you map the y axis from -10 to -5 and
specify "format y ("one" 1, "two" 2), you'll get labels like "-10",
etc. instead of "one", "two", etc. User-defined tic labels only work
in linear or square root axes.
For logarithmic axes, 'format log' controls how often major and minor
tic marks should be labeled. Enter a frequency of:
n = 1 to label all minor tics and all major tics
n = 2 to label even minor tics and all major tics
n = 3 to label minor tics 2 and 5, and all major tics
n = 4 to label minor tic 3, and all major tics
n = 5 to label only major tics.
The result of any Graphica assignment statement is displayed on the
screen. The numeric display format can be controlled using the
'format' command. The default format, called the 'short' format, shows
approximately 5 significant decimal digits. For the 'long' format
(approx. 15 digits) the last significant digit may appear to be
incorrect but the output is actually an accurate representation of the
binary number stored in the computer.
Entering 'format' by itself simply shows the currently defined formats.
Examples:
» format x 2 y 3
In this example, the x-axis labels will be printed with 2 decimal
points and the y-axis labels with 3.
» format x ("Jan" 1, "Feb" 2, "Mar" 3)
» format y ("bottom" 0, "" 10, "top" 20)
Here, we're using the user-defined axis labels. "Jan" will be printed
instead of a "1", "Feb" instead of 2, and "Mar" instead of 3. In the
second example, the label "bottom" will appear at the "0" position, and
"top" will appear at the "20" position.
» format log 2
in this case, the even minor tic marks will be labeled (2,4,6,8) for
each log cycle.
» a = 4./3.
» format short
» print a
a = 1.33333
» format long
» print a
a = 1.333333333333333
Also see EXPONENT.
≡frame
≡noframe
Purpose:
Draw a Frame
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ frame │
│ noframe │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws a frame around the subplot area. 'noframe' cancels
this effect.
Example:
» frame
produces a frame around the subplot area.
≡terminal gif
≡terminal pcx
≡terminal tif
≡dump gif
≡dump pcx
≡dump tif
≡gif
≡pcx
≡tif
Purpose:
Dump graphics in GIF, PCX or TIF formats
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ dump {gif,pcx,tif} {low,med,high,75,100,150,300} │
└──────────────────────────────────────────────────────────────────────┘
Description:
GIF files were originally developed by CompuServe as a machine
independent image file format. PCX files were originally created by
ZSoft for use by their painting packages and can be read by almost
all MS-DOS paint software and desktop publishing software.
Graphica's GIF, PCX and TIF drivers can output 16-color graphs in five
different resolutions: low (75 dpi), 100 dpi, medium (150 dpi), 200
dpi and high (300 dpi). The default is 75 dpi, corresponding to
640x480 pixels. The higher resolutions are, respectively, 1100x825,
1600x1200, 2200x1650 and 3200x2400.
It can take a little while to generate output at the higher
resolutions but Graphica can handle it, especially if you have
EMS/XMS (disk space will work, too).
Examples:
» dump gif
» dump tif "graph.tif" med
» dump pcx high
Also see TERMINAL.
≡grace
Purpose:
Specifiy a Grace Margin within the Subplot Area
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ grace <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica assumes that data points are in range if they fall within the
subplot area. To give the user a little leeway, Graphica allows a grace
margin on all axes of the subplot area before it definitely declares a
data point to be out of range and refuses to plot it.
The 'grace' command lets you specify a grace margin around the subplot
area in default units. The default is 0.0, i.e. data points falling
outside the subplot area are clipped by the software. The grace margin
can also be negative.
Example:
» grace 0.2
would allow data to be plotted within a rectangular area 0.2 inches
larger on each size of the subplot area.
≡grid
≡nogrid
Purpose:
Toggle Grid Flag
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ grid {pen {style} <integer>} {color <integer>/name} │
│ nogrid │
└──────────────────────────────────────────────────────────────────────┘
Description:
You may specify whether or not to put a set of horizontal and vertical
reference lines on a plot at the same points as the axis tic marks.
The grid may make it easier to read values off and may improve plot
appearance.
The 'grid' command sets an internal flag that signals the axis drawing
routine to generate a grid. 'nogrid' cancels this effect for subsequent
axis draws. The 'pen' and 'color' keywords may be specified to change
the appearance of the grid. The defaults are:
nogrid, pen = current pen style + 2, color = red.
Examples:
» grid
» draw x
» grid pen 2 color 3
» grid color cyan
≡help
Purpose:
Provide Online Help
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ help <topic> │
└──────────────────────────────────────────────────────────────────────┘
Invoking the HELP utility
-------------------------
The HELP utility displays information about requested Graphica topics.
From the Graphica command level (in response to the > prompt), you can
display a list of topics for which help information is available by
typing HELP (or ?) and pressing the RETURN key. The system responds by
displaying a brief description of Graphica, followed by a list of
topics for which help is available, followed by the prompt "topic?".
Specifying topic names
----------------------
To display information on a particular topic, respond to the prompt by
typing the name of the topic and pressing the RETURN key.
Subtopic information
--------------------
The information displayed by HELP on a particular topic includes a
description of the topic and a list of subtopics that further describe
the topic. To display subtopic information, type one of the subtopic
names from the list in response to the "subtopic?" prompt.
Special responses to prompts
----------------------------
If you press RETURN in response to the "subtopic?" prompt instead of
typing a subtopic name, the "topic?" prompt reappears, enabling you to
enter another topic name. If you press RETURN in response to the
"topic?" prompt, you will exit from HELP. You can also exit HELP by
pressing 'q' or ESC (escape key) at the "press any key to continue"
prompt.
You can type a question mark (?) in response to any of the prompts to
redisplay the most recently requested text and a list of topic or
subtopic names. For example, if you type ? in response to the
"subtopic?" prompt, a list of subtopics is displayed followed by the
"subtopic?" prompt.
Examples:
» help subplot
» help ?
» help
Also see ENVIRONMENT and STARTUP.
≡dump hpgl
≡terminal hpgl
≡hpgl
≡hpgl2
Purpose:
Hewlett-Packard Graphics Language
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ terminal {hpgl,hpgl2} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The hpgl device driver can also output HPGL-2 commands. This is
especially useful when you'd like filled symbols on the plotter.
I haven't implemented filled symbols in software yet. Any HPGL-2
commands sent to an hpgl plotter like the HP7475 (or a program
that understands hpgl) will be ignored.
Examples:
» term hpgl
» dump hpgl "graph1.hpg"
» dump hpgl2 "graph2.hpg"
Also see DUMP, OUTPUT and TERMINAL.
≡labels
≡titles
≡nolabels
Purpose:
Draw a Label
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ label {top,bottom,right,left} "label text" │
│ label {tag} "label_text" {at <x>,<y>} {justification} {<angle>} │
│ label {origin} <integer> │
│ title "title text" │
│ nolabel {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Draw a label. By default, the text is placed flush left against point (x,y).
If you want to adjust the way the label is positioned with respect to the
point (x,y), add the parameter <justification>, which may be 'start',
'stop' or 'center'. This indicates that the point is to be at the
left, right or center of the text. The <justification> may be
abbreviated.
The top label lies above the plot frame line. The bottom label is
drawn below the frame. 'start', 'center' and 'stop' cause the
program to halt for pen positioning if a label position was not
specified. The start label is drawn left-justified. The center
label is centered around (x,y) and the stop label is right-justified.
the top and bottom labels are centered and each subsequent label goes
either above or below the previously drawn label. The label will be
drawn at an 'angle'from the horizontal.
'tag' is an integer that is used to identify the label. If no tag
is given, the lowest unused tag value is assigned automatically. The
tag can be used to delete or change a specific label. To change any
attribute of an existing label, use the label command with the
appropriate tag, and specify the parts of the label to be changed.
The 'xlabel' command is equivalent to the label bottom command (and so
are the 'x2label', 'ylabel' and 'y2label' commands equivalent to the
label top, left and right commands.)
Entering just 'labels' or 'titles' simply shows the currently defined
labels and titles.
Examples:
to set a label at (1,2) to "y=x" use:
» label "y=x" at 1,2
to set a label "y=x^2" with the right of the text at (2,3), and
tag the label number 3, use:
» label 3 "y=x≡U2" at 2,3 stop
to change the preceding label to center justification, use:
» label 3 center
to delete label number 2 use:
» nolabel 2
to delete all labels use:
» nolabel
≡dump laserjet
≡laserjet
≡lj2
≡lj4
Purpose:
LaserJet Hardcopy
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ terminal {lj2,lj4} {low,med,high} {us,a4} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The LaserJet II driver can output graphs in five resolutions: 75 dpi
(low), 100 dpi, 150 dpi (medium), 200 dpi and 300 dpi (high). The
LaserJet 4 can also print graphs in six resolutions: 75, 100, 150 (low),
200, 300 (medium) and 600 dpi (high).
The 'us' and 'a4' switches are used by the driver to select the
correct paper tray size installed in the printer. The default is
'a4' for a paper size of 210 mm by 297 mm. The 'us' paper tray has
dimensions of 8.5 by 11 in.
Examples:
» term lj2 med
» dump lj2 "graph1.lj2" med
» dump lj4 high us
Also see DUMP, OUTPUT and TERMINAL.
≡legends
Purpose:
Draw a Legend
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ legend {framed} {offset <value>} {left} {center} │
│ {right} {flat} {stacked} {at <x>,<y>} │
│ "legend string" │
│ {pen {style} {width} <integer>} │
│ {length {value}} │
│ {symbol {<integer>}/{name}} │
│ {{pen} color {<integer>}/{name}} │
│ end │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command places a legend at a digitized location. This location
is (x,y) default units away from the lower left hand corner of the
current page size. If a line pattern is specified a small segment of
the line is drawn before the text. If a symbol is specified, that
symbol is drawn before the text. 'pen', 'length', 'symbol' and 'color'
can be specified in any order.
The 'color' command applies to the entire group (line segment, symbol
and text) but the 'pen style' and 'pen width' commands apply only to
the line segment and the symbol, not the text. The text style and
width will be those in effect just before the legend was specified. If
you want a legend with thick letters, specify 'pen width 3' before the
'legend' command.
The 'legend' command processes information until the word 'end' is
encountered. 'left', 'center' and 'right' are keywords to place the
whole legend (lines, symbols and text) at that relative given position.
'offset' specifies the separation between lines in a given legend in
multiples of the current character size. The default is 2.5 times the
character size.
'length' specifies the length of the line drawn, if one has been asked
for with the 'pen' keyword. It is in default paper units (inches).
'framed' places a frame around the legend. This frame is also a
masked area. So if you draw a legend first, then anything drawn "over"
the legend will effectively be masked out. You can only have one
"masked" area (see MASK).
'flat' is a keyword used to draw all the legend information in one
line (Lotus-style). The default mode of operation is 'stacked'.
Entering 'legends' by itself simply shows the currently defined legends.
Examples:
» legend framed at 2.0 3.0
» 'This is one line with a symbol' symbol square
» color 3 'This second line is in another color'
» pen 4 length 1.0 'one inch line'
» end
» legend center at 5.0,4.0
» symb 1 'experimental data set 1'
» symb 2 'experimental data set 2'
» pen 3 'simulation results'
» end
» legend center at 5.0,4.0 flat framed
» pen 1 'data 1'
» pen 2 'data 2'
» end
This last example draws all the legend information on one line as
compared to the other two examples above which draw stacked legends.
Also see the example script files 'legend.plt' and 'flat.plt' for
more examples.
≡lines
≡nolines
Purpose:
Draw a Line
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ line {<tag>} {from <sx>,<sy>} {to <ex>,<ey>} │
│ noline {<tag>} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command is used to make more complicated diagrams by specifying
each line to be drawn. The linked list so created may be corrected and
modified by specifying new coordinates. 'noline tag' eliminates the
line from the list. The coordinates can also be mapped units. Just
precede the 'line' command by a 'location mapped' command.
Entering 'lines' by itself simply shows the currently defined lines.
Examples:
» line from 3,4 to 6,8
» line 2 to 3,5
this last command modifies line number 2 to end at (3,5).
See also LINETO and MOVETO.
≡lineto
Purpose:
Draw a Line to a Location
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ lineto <ex>,<ey> │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws a line from the current cursor location to the
specified location. The coordinates can also be mapped units. Just
precede the 'lineto' command by a 'location mapped' command.
Entering 'lineto' by itself simply shows the currently defined lines.
Example:
» moveto 3,4
» lineto 6,8.5
moves the cursor to a point (3,4) inches away from the origin and
draws a line to point (6,8.5).
See also LINE and MOVETO.
≡load
≡batch
Purpose:
Specify an Input File
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ load <filename> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'load' command executes each command line of the specified input
file as if they had been typed in interactively. Files created by
the 'audit' command can later be loaded. Any text file containing
valid commands can be created and then executed by the 'load'
command. Files being loaded may themselves contain 'load' commands.
The 'load' command must be the last command on the line. The name of
the input file must be enclosed in single or double quotes if there
are any non-character elements in the name, e.g. file.dat has a dot
in it so you must enclose it in quotes.
You may also enter a script file directly at the DOS or UNIX command
line prompt. Or, you can enter the name of the script file without
the .PLT extension at the Graphica command line. In general, if you
input the name of something to GRAPHICA, for example 'whoa', the
GRAPHICA interpreter goes through the following steps:
1) looks to see if 'whoa' is a variable
2) checks to see if 'whoa' is a function or variable definition
3) checks if 'whoa' is a built-in command
4) checks to see if 'whoa' is an expression
5) looks in the current directory (or search path on DOS systems)
for a script file named 'whoa.plt'
Note: If you have a script file called 'spline.plt' and simply enter
'spline' at the command line, you'll be executing the spline command
rather than calling in the 'spline.plt' script file.
Examples:
» load 'work.plt'
» load "function.plt"
» my.plt
» myplot
The 'load' command is performed implicitly on any file names given as
arguments to Graphica. These are loaded in the order specified, and
then Graphica switches to interactive mode. For example,
C:\GRAPH\graphica myown.plt
will load Graphica, execute the script file myown.plt and, after a key
is pressed, switch to the > command line. To simply exit to the OS,
enter q or Q. Notice how quotes are not needed to specify data files
at the OS command line level. You may specify more than one file as
arguments to Graphica,
C:\GRAPH\graphica first.plt second.plt
≡location
Purpose:
Specify Mapped Positions
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ location {default,mapped} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command allows giving mapped (x,y) positions in commands like
'arrow', 'circle', 'label', 'legend', 'line', and 'rectangle'.
Examples:
» location mapped
turns a flag on so that the (x,y) location is interpreted as being in
mapped units.
» location default
turns the flag off so that the (x,y) location is interpreted as being
in user default units (inches, for example, which is the default.)
'location' by itself gives the status of this flag.
≡map
≡nomap
Purpose:
Specify the Limits of an Axis
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ map {x,y,y2,x2,t} <min> <max> │
│ nomap │
└──────────────────────────────────────────────────────────────────────┘
Description:
The command 'map' defines the ranges of the data for the generation
of axes. These values determine the numbers that appear along the
axes. The x range specifies a range for the bottom x-axis, the x2
range for the top x-axis, the y range is for the left y-axis and the
y2 range for the right y-axis. If this command is not specified the
subplot area is mapped automatically from the minimum and maximum
(x,y) data values entered with the data command. (This latter
procedure will only map the (x,y) axes, not the (x2,y2) axes.) The
mapping of 't' is used in polar plots only.
Mapping can be turned off with the command 'nomap'.
Entering 'map' by itself simply shows the currently mapped axes.
Examples:
» map x 0,10 y 0.0,100.0
» map y2 25,-10 x 100,200
» map t 0 3*pi
See also PARAMETRIC, POLAR, and PLOT.
≡mask
Purpose:
Specify a Masking Area
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ mask {area} {on} {off} {<x1>,<y1>,<x2>,<y2>} │
│ nomask │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'mask' command defines a masking area. Nothing is drawn over the
masked area if it is currently active. The 'legend' command for
example, creates a mask over the specified legend block and no points
or lines are drawn over it. Use 'nomask' to turn masking off or 'mask
on'/'mask off' to toggle the mask status.
Entering 'mask' by itself simply shows the currently defined mask.
Examples:
» mask 2,3 5,8
» nomask
» mask on
» mask off
≡memory
Purpose:
Memory Left
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ memory │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'memory' command gives the number of bytes left in system RAM in
the DOS version of Graphica compiled with Borland C++. Other versions
of Graphica compiled in 32-bit environments (Coherent, WATCOM C, etc.)
do not implement this command for obvious reasons (it's not needed).
Example:
» mem
would give you the following message:
System RAM available: 378,588 bytes.
≡moveto
Purpose:
Move Cursor To Location
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ moveto <sx>,<sy> │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command moves the graphics cursor to the specified location.
The coordinates can also be mapped units. Just precede the 'moveto'
command by a 'location mapped' command.
Entering 'moveto' by itself simply shows the currently defined lines.
Example:
» moveto 3.3,4
» lineto 6.2,8
moves the cursor to a point (3.3,4) inches away from the origin and
draws a line to point (6.2,8).
See also LINE and LINETO.
≡origin
≡noorigin
Purpose:
Specify Axis Origin
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ origin {x,y} {axis} <other coordinate value> │
│ noorigin │
└──────────────────────────────────────────────────────────────────────┘
Description:
The normal plot style is to have the data plotted in a box. It is
possible to cause either the x or y-axis, or both, to be drawn in such
a way that they cross at an arbitrary value. Unless told otherwise,
Graphica will always draw the axes with their origin values at the
physical origin (left bottom side of the graph).
The origin command specifies the axis origin in user defined coordinates.
Entering 'origin' by itself simply shows the currently defined axis origins.
Examples:
» origin x 0 y 0
» origin x axis 0
» norigin
≡output
Purpose:
Specify Output Unit
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ output {<filename>} {stdout} {com} {prn} │
└──────────────────────────────────────────────────────────────────────┘
Description:
By default, plots are displayed to the standard output (stdout). The
'output' command redirects the display to the specified file or device.
The filename must be enclosed in quotes. If the filename is omitted,
output will be sent to the standard output.
If you're sending output to the communications port (DOS version), make
sure you have configured your serial port with the 'mode' command. For
example,
mode com1:96,n,8,1,p
configures a serial port for use at 9600-baud, with no parity checking,
8 bits per character, one stop bit, and with retries. Graphica can
only use the 'com1:' port for output when using 'output com'.
Example:
» output 'output.dat'
sends output to the file 'output.dat'
» output com
sends output to comm port 1 (com1:)
» output prn
sends output to the printer port (prn).
Also see DUMP, OUTPUT and TERMINAL.
≡paper
≡border
≡noborder
Purpose:
Specify Paper Size
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ paper {size} <dx> {by} <dy> {default} │
│ border │
│ noborder │
└──────────────────────────────────────────────────────────────────────┘
Description:
The most basic elements of a plot are the paper (or page) and the
subplot area. The paper size usually coincides with the graphics device
hardclip limits, that is, no plotting can be done outside this region.
The paper command defines the size of the paper. Graphica sets the
page limits to the standard 11.0 by 8.5 inch paper size. If a raster
graphics terminal is being used the page border is also drawn so that the
relative size of the plot can be ascertained. This page border may be
turned off by using the command 'noborder' and on also by using 'border'.
When paper default is specified, the paper size will be reset to its
default value. The 'paper size ' command is also used to indicate that
a new plot is going to be generated.
Entering 'paper' by itself simply shows the current paper dimensions.
Examples:
» paper default
» paper 8.5 by 11
» pap size 11 8.5
Any of these three resets the paper size to the standard size of 11 by 8.5
inches.
» border
» noborder
These two commands turn the paper size outline drawing on and off,
respectively.
≡parametric
Purpose:
Plot a Parametric Curve
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ parametric {plot} t tmin,tmax fx(t),fy(t) │
│ {connect {points}} {add {symbols}} │
│ where │
│ t = any dummy variable │
│ tmin = minimum value of the dummy variable │
│ tmax = maximum value of the dummy variable │
│ fx(t) = x coordinate of each point in the curve │
│ fy(t) = y coordinate of each point in the curve │
└──────────────────────────────────────────────────────────────────────┘
Description:
The plot command allows plotting curves in Graphica in which you give
the y coordinate of each point as a function of the x coordinate. You
can also use Graphica to make parametric plots. In a parametric plot,
you give both the x and y coordinates of each point as a function of a
third parameter, say t. It takes two parametric function
specifications in terms of the parametric dummy argument to describe a
single graph. The order the parametric functions is xfunction,
yfunction. Each function operates over the common parametric domain.
Examples:
» parametric plot t 0,2*pi sin(t) sin(2*t)
» parametric t 0,2*pi sin(t) cos(t)
» parametric plot x 1,4 log(x) log(x**2+x**6)
» r(t) = (3*cos(t)**2-1)/2
» parametric plot t 0 2*pi r(t)*cos(t) r(t)*sin(t)
See also FUNCTIONS, PLOT and POLAR.
≡pause
Purpose:
Pause and/or Wait for User Response
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ pause {<expression>} {"string"} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Halts execution until a user responds at the keyboard. 'pause' is
useful in conjunction with 'load' files. It displays any text
associated with the command and then waits the specified amount of
time. This allows one to build a load file and control the amount of
time a finished graph is displayed. The first argument can be a
negative or a positive integer. Choosing -1 will have Graphica wait
until any key is hit. A positive integer will have Graphica wait for
the specified number of seconds.
The expression and string are optional. If a string is present it
must be enclosed in quotes. If no expression is given, 'pause' waits a
default time of 3 seconds.
Examples:
» pause # Wait a default three seconds
» pause 3 # Wait three seconds
» pause 10 "Isn't this great? It's a cubic spline."
» pause -1 # Wait until a carriage return is hit
» pause -1 "Hit return to continue"
≡pen
≡color
Purpose:
Specify a Pen Parameter
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ pen {style} {speed} {width} <value> │
│ pen {color} <integer>/{name} │
└──────────────────────────────────────────────────────────────────────┘
Description:
With the 'pen' command, several parameters may be specified, as follows:
To distinguish between the lines of a multiline plot, 'style' defines
the type of the line pattern to use when connecting data points or
drawing lines. The default is 1 (a solid line). All drawing commands
are affected by the 'pen style' command. In other words, the line type
remains in effect until changed. Issue a new 'pen style' command
whenever you wish to respecify the line pattern. There are 8 (eight)
pen styles available.
'width' defines the pen width in pixels or points. There are 8
(eight) pen widths available, with 1 being a line 1 pixel thick.
This is the default.
'speed' defines the pen speed in a pen plotter in cm/sec. The speed
defaults to the output device's default. On an HP7475 plotter, this
is 30 cm/sec.
'color' defines the pen color by color code or by color name.
Colors are assigned to numbers that in turn correspond to the pen
numbers on a hardware device (display screen, plotter, printer,
etc.). There are currently 16 colors defined:
0 - black 8 - lgray
1 - blue 9 - lblue
2 - green 10 - lgreen
3 - cyan 11 - lcyan
4 - red 12 - lred
5 - magenta 13 - lmagenta
6 - brown 14 - yellow
7 - gray 15 - white
Entering 'color' by itself simply shows the current drawing specifications.
The default color upon Graphica startup is green (2).
Examples:
» pen style 1, color 3
» pen width 3
» pen speed 15 (cm/s)
Also see DUMP, POSTSCRIPT and TERMINAL.
≡plot
≡noplot
≡nodata
≡errorbars
≡connect
≡add
≡needle
≡step
≡autox
Purpose:
Plot a Datafile, Curve or Function
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ plot 'data-file' {autox} │
│ {connect {points}} {add {symbols}} │
│ {needle} {step} {errorbars {itype}} │
│ plot {data} {x,y,x2,y2} │
│ {connect {points}} {add {symbols}} │
│ {needle} {step} {errorbars {itype}} │
│ plot 'definition' <function> │
│ {connect {points}} {add {symbols}} │
│ plot {p pmin pmax} <function> │
│ {connect {points}} {add {symbols}} │
│ (no)plots │
└──────────────────────────────────────────────────────────────────────┘
Definition:
This command allows you to plot data, functions and data files. It is
the primary Graphica command.
'data-file' the name of a data file enclosed in quotes. The filename
may be followed by the 'autox' keyword as in the data command. In that
case, the x values are assigned automatically starting from data point
number 1.
If 'data' is specified, previously read-in data is plotted. 'autox'
may also be specified.
<function> is a mathematical expression and may optionally be preceded
by a range specification.
'connect' causes the points to be connected by a straight line of
the specified default line pattern.
For plots with more than one line of data, it may be difficult to tell
the difference between the lines. For this reason, Graphica includes
the capability of marking each point in a line with a symbol. 'add'
causes the specified symbol to be displayed at each data point.
Leaving out the word 'add' just draws a line through the data points.
'needle' makes the plot come out such that the y data values are
plotted as needles perpendicular to the x axis.
'step' makes a step plot, useful, for example, for plotting production
data versus years.
The 'errorbars' keyword lets you add error bars to the plotted data
points. An optional integer specifies the type: 1 = no tics (dy), 2
= tics at end of bar (dy), 3 = no tics (dx), 4 = tics at end of bar
(dx). Error bar values are read in one of two ways: (a) from columns
3 and 4 of a data file (these two extra values are read in as (ylow,
yhigh) or (xlow, xhigh) values for the y values in column 2) or x
values in column (1), (b) from column 3 (this value is a dy or dx).
If you're using the 'autox' keyword you need one column less than
specified above since the x values will be assigned automatically.
Two types of error bars may be drawn: type 1 is simply a vertical
line spanning the error; type 2 has two tic marks parallel to the
x-axis, the size of the symbol, like a bracket. The default is type 2.
For axes specified as logarithmic, the log of the data values is
plotted. The log of absolute values is plotted. For zero or negative
data values, the log of 0.001 is plotted.
Optionally, a definition may be given on this line as well, for example,
'plot s=2 cos(x/s)'.
'noplot' or 'nodata' clears all data points from memory and leaves
Graphica as if no data points or functions had been entered.
'plots' by itself shows the currently defined plots, including data,
functions, smoothed curves, polynomial fits and shaded data.
If the 'column' command assigned column 3 of a data file to the x-axis
and column 1 to the y-axis, 'plot x y add points' will generate a graph
of column 3 versus column 1.
Examples:
» plot 'exp.dat' # plot data in datafile exp.dat
» plot 'bar.dat' errorbars 1 # plot error bars
» plot 'one-y.dat' autox add # plot a single column with symbols
» plot data # equivalent to 'plot x y connect'
» data 'oilrate.dat'
» draw x y
» plot data step # draw a step plot of 'oilrate.dat'
» map x 0 100 y 0 200 # map the x-axis from 0 to 100
» draw x y # draw the axes
» plot f 20 80 b(f) # plot b(f) only from 20 to 80
» plot sin(x) # plot the sine of x
» plot sin(x) cos(x) # plot sin(x) and cos(x)
» plot cos(x) add symbols connect points
» plot s=0.1, t(x) # define a variable s, plot t(x)
where t(x) has been defined previously and is a function of s.
» noplot # clear out any plot information
Also see COLUMN, FUNCTIONS, MAP, PARAMETRIC, POLAR, SAMPLING and SYMBOLS.
≡plotting
Purpose:
Select a Plotting Sequence
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ plotting sequence <start>,<stop> {{by} <increment>} │
└──────────────────────────────────────────────────────────────────────┘
Description:
If you want the program to plot the data other than in the normal
fashion (start with the first point and plot all points up to the
last one), use this command to alter the program's processing loop.
Given as integers, <start> indicates the first data point to start
at, <stop> is the last data point to plot and <increment> controls
which points to pick up within the start-stop range. The default
is to plot all points in increments of 1.
'plotting seq' without arguments shows the current plotting sequence.
Example:
» plotting sequence 2,10,2
plots points 2, 4, 6, 8 and 10.
Also see MISSING.
≡missing
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ missing {value} <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
'missing value' allows you to insert missing values in a data file and
Graphica will skip the value and start plotting another line. It works
just like the blank line feature explained in 'data'.
Example:
» missing -99999
When Graphica encounters a line containing a value of -99999 in a data
file, it'll skip that line and continue reading the data file. When
it's time to plot, the graph will be broken at those points where
Graphica read a missing value.
Also see PLOT and DATA.
≡polar
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ polar <function> {connect {points}} {add {symbols}} │
└──────────────────────────────────────────────────────────────────────┘
Definition:
This command generates polar plots and is similar to the 'plot'
command. You can plot data, functions and data files. Type PLOT
for some more details. 'polar' by itself simply gives a list of plots
made so far.
There is a dummy variable 't' which can be mapped to specify the range
of values that will be covered by the function. Polar plots are
simple transformations of a function y = f(t) where
xc = y * cos( t )
and
yc = y * sin( t )
and xc and yc are the transformed values in cartesian coordinates.
't' can be mapped as follows:
» map t <tmin> <tmax>
The default map is 0 to 2*pi. Polar plots can also be done using the
parametric function plotting feature.
Examples:
» polar .5, 1, 1.5
plots three circles of the given radius.
» polar cos(2*x)
plots a cloverleaf.
Also see FUNCTIONS, MAP, PARAMETRIC, PLOT, and SYMBOLS.
≡fits
Purpose:
Generate Curve Fits
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ fits │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica curve fit options currently include polynomial, sigmoid and
spline fitting and smoothing.
'polyfit' generates an nth degree polynomial least squares fit of the
current data. The coefficients of the polynomial are given by 'fits'.
'sigmoid' is used to interpolate the current data using a non-linear
sigmoid curve. The sigmoid will not necessarily go though every data
point. The coefficients of the sigmoid are given by 'fits'.
'spline' is used to interpolate the current data using splines under
tension. The spline goes through every data point.
'smooth' is simply used to draw a "smooth curve through scattered
data points." The smooth curve does not necessarily go through any
data point.
Spline fitting and smoothing do not produce an equation (unlike
sigmoid and polynomial fitting, which do).
Example:
» fits
Also see POLYFIT, SIGMOID, SMOOTH and SPLINE.
≡polyfit
Purpose:
Generate And Plot a Polynomial Fit
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ polyfit {degree} n {range {min} {max}} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'polyfit' command generates an nth degree polynomial least squares
fit of the current data. The highest degree possible is 10. The
default degree is 1 (i.e. 'polyfit' by itself.)
Optionally, a range of given x values may be provided and Graphica
will plot the least squares fit from min to max only.
Polynomial fits apply to the LATEST data set, that is, you can't fit a
polynomial to the last polynomial, only to a set of previously entered
data points or function.
'fits' shows the current polynomial fitting and correlation coefficients.
The number of points plotted on the polynomial fit can be changed by
the 'sampling' command.
Examples:
» polyfit degree 2
» polyfit range 20 30
» polyfit 5
» polyfit
» fits
Also see FITS, SAMPLING, SIGMOID, SMOOTH and SPLINE.
≡dump postscript
≡terminal postscript
≡postscript
≡eps
≡ps
Purpose:
PostScript Device Driver
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ dump postscript {color} {bw} {font fontname} {level2} │
│ dump epsf │
└──────────────────────────────────────────────────────────────────────┘
Description:
The PostScript device driver can output color commands. The default
is gray-scale output. Black & white output can be forced through the
'bw' switch. Color output is forced with 'color'.
Although Level 1 PostScript is the default, Level 2 output can also
be generated. (There is only one Level 2 feature active at the moment
though, setfont).
The same switches ('color', 'bw', 'font' and 'level2') apply to the
encapsulated PostScript driver (epsf).
Examples:
» dump post "graph.ps" color # used in color postscript printers
» dump post "graph.ps" bw # forces black & white output
» term postscript
See DUMP, OUTPUT and TERMINAL.
≡pwd
Purpose:
Print Current Working Directory
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ pwd │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'pwd' command prints the name of the current working directory.
Example:
» pwd
would print out C:\WORK, for example, on DOS systems or /usr/work in UNIX.
≡recall
≡editing
Purpose:
Recall User Input Lines
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ recall │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica is compiled with a feature called last-line editing and
recall. In that case, the arrow keys on the keypad can be used to
edit mistyped commands or to recall previous command lines.
Instead of retyping an entire line, simply hit the up-arrow or down-
arrow keys to recall previous input lines. Then you can move the
cursor over using the left and right-arrow keys and edit the line.
The arrow keys on the keypad work on copies of the previous input
lines, which have been saved in a moderately sized input buffer.
Here is a brief description of the arrow key functions:
^N or up arrow recall previous line
^P or down arrow recall next line
^B or left arrow move left one character
^F or right arrow move right one character
^A or home move to beginning of line
^E or end move to tend of line
^U or esc (esc) cancel current line
^H or del delete character at cursor
backspace delete character left of cursor
^K kills from current position to the end of line
^D deletes the current character, or EOF if line is empty
^L/^R redraw line in case it gets trashed
^W kills last word
RETURN returns the entire line regardless of the cursor position.
On systems without the last-line editing and recall feature, the 'recall'
command gives a list of the last 10 user input lines for review.
Example:
» recall
would give out a list such as:
paper size 11 by 8.5
subplot 2 3 6 7
frame
draw x y
≡rectangle
≡norectangle
Purpose:
Draw a Rectangle
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ rectangle {tag} {from <x1>,<y1>} {to <x2>,<y2>} {filled/nofill} │
│ norectangle {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command generates a rectangle with its lower left hand corner
at <x1>,<y1> and its upper right hand corner at <x2>,<y2>.
Entering 'rectangles' by itself simply shows the currently defined
rectangles.
Examples:
» rectangle from 1.0,2.0 to 3.0,4.0
» rectangle 2 from 3,2 to 5,4 filled
» norectangle 2
Also see ARC, ARROW, CIRCLE, LABEL, LEGEND, LINE and SECTOR.
≡range
≡stats
≡statistics
Purpose:
Generate Input Data Statistics
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ stats │
└──────────────────────────────────────────────────────────────────────┘
This command shows the input data range (max and min) of each column and
other statistical calculations such as mean, standard deviation, etc.
≡sampling
Purpose:
Specify Sampling Rate
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ sampling <expression> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica always tries to plot functions as smooth curves. It is
impossible to sample the infinite number of points that would be
needed to reproduce a given function exactly. Since the function is
only sampled at a limited number of points, Graphica can sometimes
miss features of the function. By increasing the sampling rate, you
can make Graphica sample your function at a larger number of points.
Of course, the larger the sampling rate, the longer it will take
Graphica to plot any function, even a smooth one.
The sampling rate is changed by the 'sampling' command. By default,
sampling is set to 150 points. A higher sampling rate will produce
more accurate plots, but will also take longer.
For example, the function sin(1/x) wiggles infinitely often when x
is near zero. As a result, there are slight glitches in the plot.
Increasing the sampling rate will reduce the number of glitches.
Entering 'sampling' by itself simply shows the current sampling rate.
'sampling' also affects the number of points plotted when polynomial
fitting, sigmoid fitting, spline fitting or smoothing.
Example:
» sampling 200
Also see FITS, FUNCTIONS, PARAMETRIC, PLOT, POLYFIT, SIGMOID, SPLINE
and SMOOTH.
≡save
Purpose:
Generate a File with Graphica Commands
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ save │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'save' command creates a file called 'session.log' containing a few
basic settings of your graphica session. It will not entirely reproduce
complicated graphs.
Example:
» save
≡sector
≡nosector
Purpose:
Draw a Sector
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ sector {tag} {center at <x>,<y>} │
│ {radius <value>} │
│ {start/end angle <value>} │
│ nosector {tag} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws a sector with the given radius starting at angle
<start angle> and ending at angle <end angle>.
Entering 'sector' by itself simply shows the currently defined sectors.
Examples:
» sector radius 2.0 center at 3.0 4.0 start angle 10 end 45
» sector center at 2 1 start 23 end 90
» nosectors
Also see ARC, ARROW, CIRCLE, LABEL, LEGEND, LINE, and RECTANGLE.
≡shade
Purpose:
Shade a Specified Set of Data
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ shade {spacing} {angle} <value> {mode} <integer> │
│ {(no)closure} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'shade' command allows the user to shade a specified polygon.
'spacing' is the vertical distance between shade lines in default
user units.
Optionally, a shade 'angle' may be specified. This angle is measured
from the horizontal. The sign convention for the direction of rotation
is as follows:
+ clockwise
- counterclockwise
'mode' indicates the following:
mode = 1 - shade and outline (this is the default)
mode = 2 - shade polygon only
mode = 3 - outline polygon only
The 'closure/noclosure' keyword is used to specify whether Graphica
should draw a line making the polygon a closed one or not. This
keyword is only active when mode is 1 or 3. The default is 'noclosure'.
Example:
» shade angle 35.0 mode 1
≡shell
Purpose:
Spawn a Shell
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ shell │
└──────────────────────────────────────────────────────────────────────┘
Description:
The shell command spawns an interactive shell. Use this option to
access the operating system prompt and execute commands or run other
programs. When shelling out to the operating system, you can execute
any command or application. To return to Graphica: type EXIT at the
command line (under DOS); type control-d (under Coherent); do
stop/id=xxx, where xxx is your subprocess ID (under VAX/VMS).
A single shell command may be spawned by preceding it with the $
character on the very first position of a command line. Control will
return immediately to Graphica after this command is executed.
Examples:
» shell
spawns a shell to the operating system. Type EXIT to return to Graphica.
» $dir
prints a directory listing and then returns to Graphica without waiting.
Also see DELETE, DIR, TYPE and WHAT.
≡show
Purpose:
Show Screen
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ show │
└──────────────────────────────────────────────────────────────────────┘
Description:
The SHOW command redraws your screen.
≡smooth
Purpose:
Draw a Smooth Curve Through Data
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ smooth {n} {range {min} {max}} {(no)spline} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Data smoothing is used simply as a graphical technique, to guide the
eyes through a forest of scattered data points. Graphica removes any
linear trend, uses a Fast Fourier Transform to low-pass filter the
data and reinserts the trend at the end.
If the total number of points is smaller than the current sampling
rate, Graphica generates a spline curve through the resulting smooth
points. You can force a spline fit anyway, by specifying 'spline'
on the command line. The number of points plotted on the smooth
spline curve can be changed by a previous 'sampling' command. Or,
you can prevent Graphica from drawing a spline fit regardless of the
total number of points by specifiying 'nospline'.
The user-specified constant 'n' gives the number of points over which
the data should be smoothed. A value of zero gives no smoothing at
all. If 'n' is not specified, the default is 5.
Optionally, a range of x values may be provided and Graphica will
smooth data points from min to max only.
Smoothing applies to the LATEST data set, that is, you can't smooth
a smoothed curve, only a set of previously entered data points or
function.
Examples:
» smooth 10
» smooth range 20 30
» smooth 8 spline
» smooth nospline
Also see FIT, POLYFIT, SAMPLING, SIGMOID and SPLINE.
≡sigmoid
Purpose:
Fit a Set of Data to a Sigmoid and Plot the Sigmoid
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ sigmoid {plot} {range {min} {max}} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'sigmoid' command is used to interpolate the current data using
a sigmoid curve. A sigmoid curve is simply an exponential expression
of the form: y = a + b / ( exp ( - ( x - c ) ) / d ), where a, b, c,
and d are parameters determined by the Levenberg-Marquardt method.
This is the standard method for determining non-linear least-squares
problems.
Optionally, a range of given x values may be provided and Graphica
will interpolate from min to max only.
Sigmoid fits apply to the LATEST data set, that is, you can't fit a
sigmoid to the last sigmoid, only to a set of previously entered data
points or function.
The number of points plotted on the sigmoid fit can be changed by the
'sampling' command.
Examples:
» sigmoid plot
» sigmoid range 20 30
Also see FIT, POLYFIT, SAMPLING, SMOOTH and SPLINE.
≡spline
Purpose:
Fit a Set of Data to a Spline and Plot the Spline
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ spline {plot} {tension {value}} {range {min} {max}} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'spline' command is used to interpolate the current data using
splines under tension. The produced data curve is a spline under
tension, which is somewhat "tighter" than a cubic spline, and less
likely to have spurious inflection points. The cubic spline
interpolator will produce a smooth curve through (x,y) data pairs,
even if their variation is quite complicated.
The tension factor indicates the curviness desired for the line
produced by the cubic spline. A tension in the interpolating curve
of 50 gives almost a polygonal line; a tension of 0.01 gives almost
a cubic spline. The default of 2.0 will produce a smooth curve in
most cases. For very erratic data it may be necessary to tighten
up the tension factor to 5 or 6 to adequately follow the data points.
Optionally, a range of given x values may be provided and Graphica
will interpolate from min to max only.
Spline fits apply to the LATEST data set, that is, you can't fit a
spline to the last spline, only to a set of previously entered data
points or function.
The number of points plotted on the spline fit can be changed by the
'sampling' command.
Examples:
» spline plot tension 10
» spline range 20 30
Also see FIT, POLYFIT, SAMPLING and SMOOTH.
≡subplot
Purpose:
Specify Area Where Plot Will Go
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ subplot {size/area} <xleft> <ybottom> <xright> <ytop> │
│ {default} │
└──────────────────────────────────────────────────────────────────────┘
Description:
The subplot area is also referred to as soft clip. The actual graph
resides in the subplot area but other graphic elements can be drawn
outside the subplot area.
The 'subplot' command defines the region on the paper where the plot
is drawn. By default, the subplot area is set to a rectangle of
about 60% of the paper size. The (xleft,ybottom) pair sets the
coordinates of the left bottom corner of the subplot area, while the
(xright, ytop) pair sets the coordinates of the top right hand corner
of the plotting region. If subplot default is specified, the subplot
area size will be reset to its default size.
Data points and curves are drawn or plotted on a grid space formed
by Cartesian coordinate axes. The horizontal line is the x-axis and
the vertical line is the y-axis. These axes are within the subplot
area or plotting region.
Entering 'subplot' by itself simply shows the current subplot area.
Example:
» subplot area 2.0,2.0 9.0,7.0
≡subscript
≡superscript
Purpose:
Specify Subscript and Superscript Sizes
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ subscript {size} <value> │
│ superscript {size} <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
These commands set the subscript and superscript sizes in default units.
The default values are 0.15 inches.
Example:
» subscript size 0.15
» superscript size 0.15
Also see CHARACTER FONT, CHARACTER GAP, CHARACTER RATIO, CHARACTER SIZE,
CHARACTER SLANT and TEXT.
≡symbol
Purpose:
Select a Plotting Symbol
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ symbol <code>/<name> size <value> │
└──────────────────────────────────────────────────────────────────────┘
Description:
Defines the symbol to use in displaying data points. Mnemonic codes
may be used to specify a symbol. You have a choice of 16 standard
graphics symbols and a dot:
(filled symbols)
0 - dot
1 - square 11 - fsquare
2 - circle 12 - fcircle
3 - triangle 13 - ftriangle
4 - diamond 14 - fdiamond
5 - itriangle (inv triangle) 15 - fitriangle
6 - hourglass 16 - fhourglass
7 - plus
8 - cross
9 - star
10 - pdiamond (plus within a diamond)
The default is a square ('symbol 1' or 'symbol square'). The symbol
size is specified as the height of the current symbol in default units.
The default symbol size is 0.17 inches.
If you specify 'symbol 0' or 'symbol dot', no markers will be plotted
at each point location, just a tiny point the size of a pixel, so you
can plot lots of data.
Entering 'symbol' by itself simply shows the current symbol type and
size.
(Filled symbols work only on certain hardware devices. Software symbol
fill is under development.)
Examples:
» symbol square size 0.2
» symbol 3
» sym 0
≡terminal
Purpose:
Specify Output Terminal
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ terminal {<terminal-type>} │
└──────────────────────────────────────────────────────────────────────┘
Description:
Graphica supports many different graphics devices. Use this command to
select the type of device for which Graphica will produce output.
If <terminal-type> is omitted, Graphica will show the currently defined
output terminal and list the available terminal types. <terminal-type>
may be abbreviated.
Use 'output' to redirect this output to a file, device or port.
Examples:
» terminal hpgl
» terminal
would print out the following:
available terminal types:
unknown Unknown terminal type - not a plotting device
bgi IBM PC/Clone with a Hercules/CGA/EGA/VGA graphics card
epsf Encapsulated PostScript Graphics Language
epson Epson LX-800, Star NL-10, NX-1000, etc.
gif CompuServe's GIF Format, Version 87a
hpgl HPGL Graphics Language and HP7475 plotter
hpgl2 HPGL Graphics Language and HP7550 plotter
lj2 LaserJet Series II
lj4 LaserJet 4
pcx PC Paintbrush PCX Format
pic Lotus 1-2-3 PIC Graphics Format
postscript PostScript Graphics Language
tif Tagged Image File Format Revision 6.0
and possibly (depending on the version you have) any of the following:
cbm Coherent Bitmap Graphics
latex LaTeX picture environment
windows IBM PC/Clone running Windows 3.1
Notes on some of the graphics formats:
--------------------------------------
The software fonts will look identically whether you use hpgl, PIC,
PostScript or any other driver. The only difference comes from the
slight resolution difference in the formats. The standard hpgl
resolution is 10365 by 7962 pixels. The Lotus 1-2-3 PIC format has
a fixed resolution of 3200 by 2311 pixels. The PostScript driver
outputs graphic information at a resolution of 7920 by 6120 pixels.
The hpgl, PIC and PostScript drivers output portrait files by
turning the paper around 90 degrees. An HPGL graph will come out
alright on an actual HP plotter (which has its paper always in the
landscape orientation). If you need to import the file into a
program that can read any of these formats, you'll have to rotate
the plot back a quarter turn.
The Lotus 1-2-3 PIC format should not be confused with the PC Paint
Plus format, PPIC or with Dr. Halo PIC format. Some programs only
look at the file extension instead of looking inside the file to
determine what type of graphics information is in it. For example,
the graphics viever VPIC won't read PIC files generated by Graphica
(because it thinks it's something else). WordPerfect for DOS and
Word for Windows will read Graphica PIC files without a hitch.
See DUMP and OUTPUT.
≡tics
Purpose:
Specify Tic Mark Size and Direction
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ tic {size} <major value> <minor value> {<direction>} │
└──────────────────────────────────────────────────────────────────────┘
Description:
All axes are marked off in equal segments with tic marks. The values
major and minor determine the size of the major and minor tic marks.
The defaults are 0.16 and 0.09 inches for the major and minor tic marks,
respectively.
By default, tics are drawn inwards from the border on all four sides.
The 'tic' command can be used to change the tics to be drawn outwards.
<direction> may be in, out or nothing (which is the same as in).
Entering 'tics' by itself simply shows the current tic size and direction.
Example:
» tic size 0.1 0.06
» tics in
≡timestamp
≡notimestamp
Purpose:
Toggle Plotter Stamp On/Off
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ timestamp │
│ notimestamp │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command toggles the timestamp on and off on a non-screen plot
(plotter or printer). The timestamp is simply a message drawn near
the bottom of the page as follows:
Graphica version 2.5 Thu Mar 3 11:34:14 1994
'timestamp' activates printing of the message ; 'notimestamp'
deactivates it. The default is OFF. You may put a 'timestamp'
command in your 'graphica.ini' initialization file if you'd like to
generate this message in your hardcopy output.
Examples:
» timestamp
» notimestamp
Also see STARTUP.
≡type
≡more
Purpose:
Displays a File
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ type <file> │
│ more <file> │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'type' command displays the contents of a file. Pathnames, wildcards,
and drive designators may be used in the usual way for your operating
system. Other operating system commands can be issued using the $
character on the very first position of a line followed by a command.
'more' is the UNIX version of the command.
Examples:
» type script.plt
lists the ASCII file script.plt.
» type foo
lists the ASCII file foo.
Also see DEL, DIR, SHELL and WHAT.
≡units
Purpose:
Specify Drawing Units
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ units <unit type> │
└──────────────────────────────────────────────────────────────────────┘
Description:
It is sometimes desirable to use units other than inches, i.e., the
metric system, with Graphica. To change the unit of measure for
parameters which are usually given in inches use the unit command.
This command defines the units to be used in subsequent commands which
represent a length or position normally supplied in inches, such as in
paper size, subplot area, etc.
The <unit type> may be 'in', 'cm' or 'mm'.
Entering 'units' by itself simply shows the current units of measure.
Changing the units of measure also changes the built-in variable
'ufactor'.
Example:
» units cm
See VARIABLES.
≡variables
≡userdefined
≡who
User-defined function syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ <function-name>( <dummyvar 1> {, <dummyvar 2> } ) = <expression> │
│ │
│ where │
│ <expression> is defined in terms of <dummyvar 1> and <dummyvar 2> │
└──────────────────────────────────────────────────────────────────────┘
User-defined variable syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ <variable-name> = <constant-expression> │
│ variables │
└──────────────────────────────────────────────────────────────────────┘
Description:
You may define your own functions and variables. User-defined functions
and variables may be used anywhere an expression is called for. A function
refers to a general expression and can take one or two arguments (dummy
variables).
The WHO or VARIABLES command lists all pre-defined and user-defined
variables together with their values.
The following variables have already been defined for you:
pi = 3.14159
e = 2.71828
catalan = 0.91597
degree = 0.01745
ufactor = 1.00000
gamma = 0.57721
golden = 1.61803
where pi is the mathematical constant π, e is the exponential constant,
catalan is Catalan's constant, degree gives the number of radians in one
degree (pi/180), ufactor is a conversion factor used to convert from
inches to user-defined units (cm and mm), gamma is Euler's constant,
and golden is the golden ratio (1+sqrt(5))/2. These constants have
been predefined for you but you may change them (so they are really
variables).
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
» comb(n,k) = n!/(k!*(n-k)!)
Note: case matters, e.g., 'Alpha' is different from 'alpha'.
Also see FUNCTIONS.
≡view
Purpose:
Move Paper to View Plotter Output
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ view │
└──────────────────────────────────────────────────────────────────────┘
Description:
Retracts the pen and advances the paper on a pen plotter to view the
graph fully. This command is similar to pushing the VIEW button on
Hewlett-Packard HP7475 or HP7550 plotters.
Example:
» view
would move the plotting paper outward into view.
≡x
≡y
≡x2
≡y2
≡logarithmic
≡linear
≡sqr
Purpose:
Specify Axis Type
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ {x,y,y2,x2} {linear,logarithmic,probability,sqr} │
└──────────────────────────────────────────────────────────────────────┘
Description:
With this command, the kind of axis to be plotted may be specified, as
follows:
linear - specifies a linear axis. A linear scale is a standard base 10
numeric scale. This is the default.
logarithmic - specifies a log axis. A log scale is a base 10
logarithmic scale. If a regression has been performed, the values for
that particular axis are logarithmic. Given the mapped range for an
axis, the logarithmic range for that axis will be determined
automatically. If an axis is to be logarithmic, there is no need to
specify the number of divisions or the format. If the range is
negative as specified in a map command, Graphica automatically converts
it to positive. Zero values for min or max will cause the log axis to
begin at 0.001.
probability - a probability scale is the inverse of the Gaussian
cumulative distribution function. Thus the graph of the sigmoidally
shaped Gaussian cumulative distribution function on a probability scale
will be a straight line.
Probabilities are expressed as a percentage so that the range of the
scale is from 0 to 100. The minimum and maximum values that a
probability axis can take in Graphica are 0.01 and 99.99. A probability
axis label could be specified as something like "cumulative frequency, %".
sqr - square-root axis. Used in some engineering applications. A square
root scale is based on the square root of the axis in question.
Examples:
» x lin
» y log
» x2 pro
» x sqr
≡xlabel
≡ylabel
≡x2label
≡y2label
Purpose:
Draw an Axis Label
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ {xlabel,x2label,ylabel,y2label} 'string' {rotate} │
└──────────────────────────────────────────────────────────────────────┘
Description:
This command draws a centered label for that axis. The label text must
be enclosed in single or double quotes. All labels are drawn using the
current character font and size. The label bottom command is equivalent
to the xlabel command. Likewise, the 'label top', 'left', and 'right'
commands are equivalent to the 'x2label', 'ylabel' and 'y2label' commands.
The ROTATE switch turns the labels around 180 degrees. This may
become especially useful when drawing the y2-label (some people prefer
the y2-label to "face" left rather than right).
Examples:
» xlabel 'This is the x-axis label'
» ylabel 'This is the y-axis label'
» y2label 'rotated y2-label' rotate
≡expressions
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ <expression> │
└──────────────────────────────────────────────────────────────────────┘
Description:
You can determine the value of expressions or variables by just typing
the expression or variable at the » prompt.
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 variables may be expressed as {<real>,<imag>}, where <real> and
<imag> must be numbers. For example, {3,2} represents 3 + 2i; {0,1}
represents 'i' itself. The curly braces are explicitly required.
Examples:
» 2*3
would print out '2*3 = 6'
» 30+2*2
would print out '30+2*2 = 34'
≡complex
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ Complex Variables │
└──────────────────────────────────────────────────────────────────────┘
Complex variables may be expressed as {<real>,<imag>}, where <real> and
<imag> must be numbers. For example, {3,2} represents 3 + 2i; {0,1}
represents 'i' itself. The curly braces are explicitly required.
Also see EXPRESSIONS and FUNCTIONS.
≡expressions functions
≡functions
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ functions │
└──────────────────────────────────────────────────────────────────────┘
All functions in Graphica accept integer, real, and complex arguments,
unless otherwise noted.
The 'functions' command by itself lists all user-defined functions and
their definitions.
Graphica also supports the following special functions:
Gamma function y = gamma( x )
Natural logarithm of gamma function y = lgamma( x )
Incomplete gamma integral y = igamma( a, x )
Complemented incomplete gamma integral y = igamc( a, x )
Inverse of complemented incomplete gamma integral x = igami( a, y )
Incomplete beta integral y = ibeta( a, b, x )
Inverse of incomplete beta integral x = ibetai( a, b, y )
Error function y = erf( x )
Complementary error function y = erfc( x )
Inverse error function x = ierf( y )
Also see VARIABLES.
≡expressions functions abs
≡functions abs
≡abs
┌──────────────────────────────────────────────────────────────────────┐
│ abs │
└──────────────────────────────────────────────────────────────────────┘
abs(z) returns the absolute value of the real or complex number z.
The returned value is of the same type as the argument. For complex
arguments, abs(z) returns the complex modulus (magnitude) defined as
the length of z in the complex plane:
sqrt( real(z)**2 + imag(z)**2 )
≡expressions functions acos
≡functions acos
≡acos
┌──────────────────────────────────────────────────────────────────────┐
│ acos │
└──────────────────────────────────────────────────────────────────────┘
acos(z) returns the arc cosine (inverse cosine) of z. All results
are given in radians. For real z, such that abs(z) <= 0.0, the
result is in the range 0 to π. Complex results are obtained if
abs(z) > 1.0, or if z is complex. The complex arc cosine is defined as:
acos(z) = -i log( z + i sqrt(1-z**2) )
≡expressions functions acosh
≡functions acosh
≡acosh
┌──────────────────────────────────────────────────────────────────────┐
│ acosh │
└──────────────────────────────────────────────────────────────────────┘
acosh(z) returns the arc hyperbolic cosine (inverse hyperbolic cosine)
of z. All results are given in radians. For real z, such that abs(z) <=
0.0, the result is in the range 0 to π. Complex results are obtained if
abs(z) > 1.0, or if z is complex. The complex arc cosine is defined as:
acosh(z) = -i log( z + i sqrt(1-z**2) )
≡expressions functions arg
≡functions arg
≡arg
┌──────────────────────────────────────────────────────────────────────┐
│ arg │
└──────────────────────────────────────────────────────────────────────┘
arg(z) returns the phase angle of a complex number z, in radians.
The result is always between -π and π.
For complex z = x + iy = r exp(i theta), the magnitude and phase
are given by
r = abs(z)
theta = arg(z)
≡expressions functions asin
≡functions asin
≡asin
┌──────────────────────────────────────────────────────────────────────┐
│ asin │
└──────────────────────────────────────────────────────────────────────┘
asin(z) returns the arc sine (inverse sine) of z. All results are
given in radians. For real z, such that abs(z) <= 1.0, the result is
in the range -π/2 to π/2. Complex results are obtained if abs(z) >
1.0, or if z is complex. The complex arc sine is defined as:
asin(z) = -i log( iz + sqrt(1-z**2) )
≡expressions functions asinh
≡functions asinh
≡asinh
┌──────────────────────────────────────────────────────────────────────┐
│ asinh │
└──────────────────────────────────────────────────────────────────────┘
asinh(z) returns the arc hyperbolic sine (inverse hyperbolic sine)
of z. All results are given in radians. For real z, such that
abs(z) <= 1.0, the result is in the range -π/2 to π/2. Complex
results are obtained if abs(z) > 1.0, or if z is complex. The
complex arc sine is defined as:
asinh(z) = -i log( iz + sqrt(1-z**2) )
≡expressions functions atan
≡functions atan
≡atan
┌──────────────────────────────────────────────────────────────────────┐
│ atan │
└──────────────────────────────────────────────────────────────────────┘
atan(z) returns the arc tangent (inverse tangent) of z. All results
are given in radians. For real z, the result is in the range -π/2 to
π/2. If z is complex, the complex arc tangent is returned:
atan(z) = i/2 log( (i+z) / (i-z) )
≡expressions functions atanh
≡functions atanh
≡atanh
┌──────────────────────────────────────────────────────────────────────┐
│ atanh │
└──────────────────────────────────────────────────────────────────────┘
atanh(z) returns the arc hyperbolic tangent (inverse hyperbolic
tangent) of z. All results are given in radians. For real z, the
result is in the range -π/2 to π/2. If z is complex, the complex arc
tangent is returned:
atanh(z) = i/2 log( (i+z) / (i-z) )
≡expressions functions ibeta
≡functions ibeta
≡ibeta
┌──────────────────────────────────────────────────────────────────────┐
│ ibeta │
└──────────────────────────────────────────────────────────────────────┘
ibeta(p,q,z) returns the incomplete beta function of the real parts of
its arguments (p, q>0 and 0<z<1). If the arguments are complex, the
imaginary components are ignored. The function is defined as
x
- -
| (a+b) | | a-1 b-1
----------- | t (1-t) dt.
- - | |
| (a) | (b) -
0
≡expressions functions ibetai
≡functions ibetai
≡ibetai
┌──────────────────────────────────────────────────────────────────────┐
│ ibetai │
└──────────────────────────────────────────────────────────────────────┘
x = ibetai(a,b,y) returns the inverse of the incomplete beta function
of the real parts of its arguments (p, q>0 and 0<z<1). If the arguments
are complex, the imaginary components are ignored. Given y, the function
finds x such that ibeta( a, b, x ) = y.
≡expressions functions ceil
≡functions ceil
≡ceil
┌──────────────────────────────────────────────────────────────────────┐
│ ceil │
└──────────────────────────────────────────────────────────────────────┘
ceil(z) returns the smallest integer greater than z. For complex
numbers, ceil returns the smallest integer greater than the real part of z.
≡expressions functions cos
≡functions cos
≡cos
┌──────────────────────────────────────────────────────────────────────┐
│ cos │
└──────────────────────────────────────────────────────────────────────┘
cos(z) returns the cosine of z, where z is in radians.
For complex z = x + iy, the complex cosine is returned:
cos(z) = cos(x) cosh(y) - u sin(x) sinh(y)
≡expressions functions cosh
≡functions cosh
≡cosh
┌──────────────────────────────────────────────────────────────────────┐
│ cosh │
└──────────────────────────────────────────────────────────────────────┘
cosh(z) returns the hyperbolic cosine of z, where z is in radians.
≡expressions functions exp
≡functions exp
≡exp
┌──────────────────────────────────────────────────────────────────────┐
│ exp │
└──────────────────────────────────────────────────────────────────────┘
exp(z) returns the exponential function of z (e raised to the power
of z). For complex z = x + iy, the complex exponential is returned:
exp(z) = exp(x) ( cos(y) + i sin(y) )
≡expressions functions erf
≡functions erf
≡erf
┌──────────────────────────────────────────────────────────────────────┐
│ erf │
└──────────────────────────────────────────────────────────────────────┘
erf(x) returns the error function of x. erf(x) is the integral of the
normal (Gaussian) probability distribution function from 0 to x. The
error function is central to many calculations in statistics. It is
defined as:
erf(x) = 2/sqrt(pi) integral(0,x) exp(-t^2)
Also see ERFC and IERF.
≡expressions functions erfc
≡functions erfc
≡erfc
┌──────────────────────────────────────────────────────────────────────┐
│ erfc │
└──────────────────────────────────────────────────────────────────────┘
erfc(x) returns the complementary error function of x. erfc(x) is
simply 1.0 - erf(x), where erf(x) is the integral of the normal
(Gaussian) probability distribution function from 0 to x.
1 - erf(x) =
inf
-
2 | | 2
erfc(x) = -------- | exp( - t ) dt
sqrt(pi) | |
-
x
Also see ERF and IERF.
≡expressions functions floor
≡functions floor
≡floor
┌──────────────────────────────────────────────────────────────────────┐
│ floor │
└──────────────────────────────────────────────────────────────────────┘
floor(z) returns the greatest integer less than or equal to z. For
complex numbers, floor returns the largest integer not greater than
the real part of z.
≡expressions functions gamma
≡functions gamma
≡gamma
┌──────────────────────────────────────────────────────────────────────┐
│ gamma │
└──────────────────────────────────────────────────────────────────────┘
gamma(z) returns the gamma function of the real part of z. For
integer z, gamma(z+1) = z!. If z is a complex value, the imaginary
component is ignored.
Also see IGAMMA, LGAMMA, IGAMC, IGAMI.
≡expressions functions lgamma
≡functions lgamma
≡lgamma
┌──────────────────────────────────────────────────────────────────────┐
│ lgamma │
└──────────────────────────────────────────────────────────────────────┘
lgamma(z) returns the base e (2.718...) logarithm of the absolute
value of the gamma function of the argument.
Also see GAMMA, IGAMMA, IGAMC, IGAMI.
≡expressions functions igamc
≡functions igamc
≡igamc
┌──────────────────────────────────────────────────────────────────────┐
│ igamc │
└──────────────────────────────────────────────────────────────────────┘
igamc(a,x) returns the complemented incomplete gamma integral. This
function is defined by
igamc(a,x) = 1 - igamma(a,x)
inf
-
1 | | -t a-1
= ----- | e t dt.
- | |
| (a) -
x
Also see GAMMA, IGAMMA, LGAMMA, IGAMI.
≡expressions functions igami
≡functions igami
≡igami
┌──────────────────────────────────────────────────────────────────────┐
│ igami │
└──────────────────────────────────────────────────────────────────────┘
igami(a,y) returns the inverse of the complemented incomplete gamma
integral. Given y, the function finds x such that igamc( a, x ) = y.
Also see GAMMA, IGAMMA, LGAMMA, IGAMC.
≡expressions functions ierf
≡functions ierf
≡ierf
┌──────────────────────────────────────────────────────────────────────┐
│ ierf │
└──────────────────────────────────────────────────────────────────────┘
ierf(z) returns the inverse error function of the real part of z. The
error function, erf(x), is the integral of the normal (Gaussian)
probability distribution function from 0 to x.
Also see ERF and ERFC.
≡expressions functions igamma
≡functions igamma
≡igamma
┌──────────────────────────────────────────────────────────────────────┐
│ igamma │
└──────────────────────────────────────────────────────────────────────┘
igamma(a,z) returns the incomplete gamma function of the real parts of
its arguments (a > 0 and z >= 0). If the arguments are complex, the
imaginary components are ignored.
The function is defined by
x
-
1 | | -t a-1
igamma(a,x) = ----- | e t dt.
- | |
| (a) -
0
Also see GAMMA and FUNCTIONS.
≡expressions functions imag
≡functions imag
≡imag
┌──────────────────────────────────────────────────────────────────────┐
│ imag │
└──────────────────────────────────────────────────────────────────────┘
imag(z) returns the imaginary part of z as a real number.
≡expressions functions int
≡functions int
≡int
┌──────────────────────────────────────────────────────────────────────┐
│ int │
└──────────────────────────────────────────────────────────────────────┘
int(z) returns the integer part of z, truncated toward zero.
≡expressions functions ln
≡functions ln
≡ln
┌──────────────────────────────────────────────────────────────────────┐
│ ln │
└──────────────────────────────────────────────────────────────────────┘
ln(z) returns the natural logarithm (base e) of z. For complex or
negative z, the complex logarithm is returned:
ln(z) = ln( abs(z) ) + i atan2( y, x )
≡expressions functions log
≡functions log
≡log
┌──────────────────────────────────────────────────────────────────────┐
│ log │
└──────────────────────────────────────────────────────────────────────┘
log(z) returns the logarithm (base 10) of z. For complex or
negative z, the complex logarithm is returned:
log(z) = log( abs(z) ) + i atan2( y, x )
≡expressions functions rand
≡functions rand
≡rand
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ rand │
└──────────────────────────────────────────────────────────────────────┘
Syntax:
rand
rand(0)
rand(1)
Description:
rand(0) returns a pseudorandom number in the interval (0.0,1.0)
using a uniform distribution. rand(1) returns a pseudorandom
number using a normal distribution with mean 0.0 and variance 1.0.
Entering 'rand' by itself is equivalent to entering 'rand(0)'.
When Graphica starts up, it takes the time of day (measured in
small fractions of a second) as the seed for the pseudorandom
number generator. Two different Graphica sessions will therefore
almost always give different sequences of pseudorandom numbers.
If you want to make sure that you always get the same sequence
of pseudorandom numbers, you can explicitly give a seed for the
pseudorandom number generator, using 'seed'.
Examples:
» rand(0)
» plot rand(0) add
» rand
» rand(1)
Also see FUNCTIONS and SEED.
≡seed
Purpose:
Seed the Random Number Generator
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ seed │
└──────────────────────────────────────────────────────────────────────┘
Syntax:
seed n
Description:
'seed' explicitly gives a seed for the pseudorandom number generator.
Example:
» seed 321
» rand
rand = 0.27789
» rand
rand = 0.41721
To repeat the sequence exactly, reseed the number generator:
» seed 321
» rand
rand = 0.27789
» rand
rand = 0.41721
Also see RAND.
≡expressions functions real
≡functions real
≡real
┌──────────────────────────────────────────────────────────────────────┐
│ real │
└──────────────────────────────────────────────────────────────────────┘
real(z) returns the real part of z.
≡expressions functions sgn
≡functions sgn
≡sgn
┌──────────────────────────────────────────────────────────────────────┐
│ sgn │
└──────────────────────────────────────────────────────────────────────┘
sgn(z) returns 1 if z is positive, -1 if z is negative, and 0 if z is 0.
If z is a complex value, the imaginary component is ignored.
≡expressions functions sin
≡functions sin
≡sin
┌──────────────────────────────────────────────────────────────────────┐
│ sin │
└──────────────────────────────────────────────────────────────────────┘
sin(z) returns the sine of z, where z is in radians.
For complex z = x + iy, the complex sine is returned:
sin(z) = sin(x) cosh(y) - i cos(x) sinh(y)
≡expressions functions sinh
≡functions sinh
≡sinh
┌──────────────────────────────────────────────────────────────────────┐
│ sinh │
└──────────────────────────────────────────────────────────────────────┘
sinh(z) returns the hyperbolic sine of z, where z is in radians.
≡expressions functions sqrt
≡functions sqrt
≡sqrt
┌──────────────────────────────────────────────────────────────────────┐
│ sqrt │
└──────────────────────────────────────────────────────────────────────┘
sqrt(z) returns the square root of z.
≡expressions functions tan
≡functions tan
≡tan
┌──────────────────────────────────────────────────────────────────────┐
│ tan │
└──────────────────────────────────────────────────────────────────────┘
tan(z) returns the tangent of z, where z is in radians.
For complex z, the complex tangent sin(z)/cos(z) is returned.
≡expressions functions tanh
≡functions tanh
≡tanh
┌──────────────────────────────────────────────────────────────────────┐
│ tanh │
└──────────────────────────────────────────────────────────────────────┘
tanh(z) returns the hyperbolic tangent of z, where z is in radians.
≡expressions operators
≡operators
┌──────────────────────────────────────────────────────────────────────┐
│ Operators │
└──────────────────────────────────────────────────────────────────────┘
All operators in Graphica accept integer, real, and complex arguments,
unless otherwise noted. The ** operator (exponentiation) is supported,
as in FORTRAN.
Parentheses may be used to change the order of evaluation.
≡expressions operators binary
≡operators binary
≡binary
┌──────────────────────────────────────────────────────────────────────┐
│ Binary Operators │
└──────────────────────────────────────────────────────────────────────┘
The following is a list of all the binary operators and their usage:
symbol example explanation
** a**b exponentiation
* a*b multiplication
/ a/b division
\ a\b left 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
(*) 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.
Multiplication must be explicitly noted with the asterisk; adjacent
parenthetical terms such as (a+b)(c-4) are not automatically multiplied.
The left division a\b is equivalent to b/a.
≡expressions operators ternary
≡operators ternary
≡ternary
┌──────────────────────────────────────────────────────────────────────┐
│ Ternary Operators │
└──────────────────────────────────────────────────────────────────────┘
The following is a list of the ternary operator and its usage:
symbol example explanation
≡: a≡b:c * ternary operation
(*) Operator requires an integer argument.
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.
≡expressions operators unary
≡operators unary
≡unary
┌──────────────────────────────────────────────────────────────────────┐
│ Unary Operators │
└──────────────────────────────────────────────────────────────────────┘
The following is a list of all the unary operators and their usage:
symbol example explanation
- -a unary minus
~ ~a * one's complement
! !a * logical negation
! a! * factorial
(*) Operator requires an integer argument.
The factorial operator returns a real number to allow a greater range.
≡probability
┌──────────────────────────────────────────────────────────────────────┐
│ Probability Distribution Functions │
└──────────────────────────────────────────────────────────────────────┘
Probability distribution functions are used in the mathematics areas of
probability and statistics. If an experiment can occur in 'n' mutually
exclusive and equally likely ways, and if exactly 'm' of these ways
correspond to an event 'E', then the probability of 'E' is given by
m
P(E) = -.
n
The probability that the value of a random variable 'X' is less than or
equal to some real number 'x' is defined as
F(x) = P(X ≤ x), -∞ < x < ∞
= integral(-∞ to x) f(x) dx
where f(x) is called the probability density of the random variable X.
Graphica implements 20 probability distribution functions. Refer to
a good statistics textbook for details. The functions are:
Binomial distribution y = bdtr( k, n, p )
Complemented Binomial distribution y = bdtrc( k, n, p )
Inverse Binomial distribution p = bdtri( k, n, y )
Negative Binomial distribution y = nbdtr( k, n, p )
Complemented Negative Binomial distribution y = nbdtrc( k, n, p )
Beta distribution y = btdtr( a, b, x )
Chi-square distribution y = chdtr( df, x )
Complemented Chi-square distribution y = chdtrc( v, x )
Inverse of Complemented Chi-square distribution x = chdtri( df, y )
F distribution y = fdtr( df1, df2, x )
Complemented F distribution y = fdtrc( df1, df2, x )
Inverse of Complemented F distribution x = fdtri( df1, df2, y )
Gamma distribution y = gdtr( a, b, x )
Complemented Gamma distribution y = gdtrc( a, b, x )
Normal distribution y = ndtr( x )
Inverse of Normal distribution x = ndtri( y )
Poisson distribution y = pdtr( k, m )
Complemented Poisson distribution y = pdtrc( k, m )
Inverse Poisson distribution m = pdtri( k, y )
Student's t distribution y = stdtr( k, t )
Also see BDTR, BDTRC, BDTRI, NBDTR, NBDTRC, BTDTR, CHDTR, CHDTRC,
CHDTRI, FDTR, FDTRC, FDTRI, GDTR, GDTRC, NDTR, NDTRI, PDTR, PDTRC,
PDTRI, and STDTR for more details.
≡expressions functions bdtr
≡functions bdtr
≡bdtr
┌──────────────────────────────────────────────────────────────────────┐
│ bdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
bdtr(k,n,p) returns the sum of the terms 0 through k of the Binomial
probability density:
k
-- ( n ) j n-j
> ( ) p (1-p)
-- ( j )
j=0
The terms are not summed directly; instead the incomplete beta
integral is employed, according to the formula
y = bdtr( k, n, p ) = ibeta( n-k, k+1, 1-p ).
The arguments must be positive, with p ranging from 0 to 1.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions bdtrc
≡functions bdtrc
≡bdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ bdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
bdtrc(k,n,p) returns the sum of the terms k+1 through n of the Binomial
probability density:
n
-- ( n ) j n-j
> ( ) p (1-p)
-- ( j )
j=k+1
The terms are not summed directly; instead the incomplete beta integral
is employed, according to the formula
y = bdtrc( k, n, p ) = ibeta( k+1, n-k, p ).
The arguments must be positive, with p ranging from 0 to 1.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions bdtri
≡functions bdtri
≡bdtri
┌──────────────────────────────────────────────────────────────────────┐
│ bdtri │
└──────────────────────────────────────────────────────────────────────┘
Description:
bdtri(k,n,y) finds the event probability p such that the sum of the
terms 0 through k of the Binomial probability density is equal to the
given cumulative probability y. This is accomplished using the inverse
beta integral function and the relation
1 - p = ibetai( n-k, k+1, y ).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions nbdtr
≡functions nbdtr
≡nbdtr
┌──────────────────────────────────────────────────────────────────────┐
│ nbdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
nbdtr(k,n,p) returns the sum of the terms 0 through k of the negative
binomial distribution:
k
-- ( n+j-1 ) n j
> ( ) p (1-p)
-- ( j )
j=0
In a sequence of Bernoulli trials, this is the probability that k or
fewer failures precede the nth success.
The terms are not computed individually; instead the incomplete beta
integral is employed, according to the formula
y = nbdtr( k, n, p ) = ibeta( n, k+1, p ).
The arguments must be positive, with p ranging from 0 to 1.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions nbdtrc
≡functions nbdtrc
≡nbdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ nbdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
nbdtrc(k,n,p) returns the sum of the terms k+1 to infinity of the negative
binomial distribution:
inf
-- ( n+j-1 ) n j
> ( ) p (1-p)
-- ( j )
j=k+1
The terms are not computed individually; instead the incomplete beta
integral is employed, according to the formula
y = nbdtrc( k, n, p ) = ibeta( k+1, n, 1-p ).
The arguments must be positive, with p ranging from 0 to 1.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions btdtr
≡functions btdtr
≡btdtr
┌──────────────────────────────────────────────────────────────────────┐
│ btdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
btdtr(a,b,x) returns the area from zero to x under the beta density
function:
x
- -
| (a+b) | | a-1 b-1
P(x) = ---------- | t (1-t) dt
- - | |
| (a) | (b) -
0
This function is identical to the incomplete beta integral function
ibeta(a, b, x).
The complemented function is
1 - P(1-x) = ibeta( b, a, x )
Also see FUNCTIONS and PROBABILITY.
≡expressions functions chdtr
≡functions chdtr
≡chdtr
┌──────────────────────────────────────────────────────────────────────┐
│ chdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
chdtr(df,x) returns the area under the left hand tail (from 0 to x) of
the Chi square probability density function with v degrees of freedom.
inf
-
1 | | v/2-1 -t/2
P( x | v ) = ----------- | t e dt
v/2 - | |
2 | (v/2) -
x
where x is the Chi-square variable.
The incomplete gamma integral is used, according to the formula
y = chdtr( v, x ) = igamma( v/2.0, x/2.0 ).
The arguments must both be positive.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions chdtrc
≡functions chdtrc
≡chdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ chdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
chdtrc(v,x) returns the area under the right hand tail (from x to
infinity) of the Chi square probability density function with v
degrees of freedom:
inf
-
1 | | v/2-1 -t/2
P( x | v ) = ----------- | t e dt
v/2 - | |
2 | (v/2) -
x
where x is the Chi-square variable.
The incomplete gamma integral is used, according to the formula
y = chdtr( v, x ) = igamc( v/2.0, x/2.0 ).
The arguments must both be positive.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions chdtri
≡functions chdtri
≡chdtri
┌──────────────────────────────────────────────────────────────────────┐
│ chdtri │
└──────────────────────────────────────────────────────────────────────┘
Description:
chdtri(df,y) finds the Chi-square argument x such that the integral
from x to infinity of the Chi-square density is equal to the given
cumulative probability y.
This is accomplished using the inverse gamma integral function and
the relation
x/2 = igami( df/2, y )
Also see FUNCTIONS and PROBABILITY.
≡expressions functions fdtr
≡functions fdtr
≡fdtr
┌──────────────────────────────────────────────────────────────────────┐
│ fdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
fdtr(df1,df2,x) returns the area from zero to x under the F density
function (also known as Snedcor's density or the variance ratio density).
This is the density of x = (u1/df1)/(u2/df2), where u1 and u2 are random
variables having Chi square distributions with df1 and df2 degrees of
freedom, respectively.
The incomplete beta integral is used, according to the formula
P(x) = ibeta( df1/2, df2/2, (df1*x/(df2 + df1*x) ).
The arguments a and b are greater than zero, and x x is nonnegative.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions fdtrc
≡functions fdtrc
≡fdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ fdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
fdtrc(df1,df2,x) returns the area from x to infinity under the F density
function (also known as Snedcor's density or the variance ratio density).
inf
-
1 | | a-1 b-1
1-P(x) = ------ | t (1-t) dt
B(a,b) | |
-
x
The incomplete beta integral is used, according to the formula
P(x) = ibeta( df2/2, df1/2, (df2/(df2 + df1*x) ).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions fdtri
≡functions fdtri
≡fdtri
┌──────────────────────────────────────────────────────────────────────┐
│ fdtri │
└──────────────────────────────────────────────────────────────────────┘
Description:
fdtri(df1,df2,y) returns the F density argument x such that the integral
from x to infinity of the F density is equal to the given probability y.
This is accomplished using the inverse beta integral
function and the relations
z = ibetai( df2/2, df1/2, y )
x = df2 (1-z) / (df1 z).
Note: the following relations hold for the inverse of
the uncomplemented F distribution:
z = ibetai( df1/2, df2/2, y )
x = df2 z / (df1 (1-z)).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions gdtr
≡functions gdtr
≡gdtr
┌──────────────────────────────────────────────────────────────────────┐
│ gdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
gdtr(a,b,x) returns the integral from zero to x of the gamma probability
density function:
x
b -
a | | b-1 -at
y = ----- | t e dt
- | |
| (b) -
0
The incomplete gamma integral is used, according to the relation
y = igamma( b, ax ).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions gdtrc
≡functions gdtrc
≡gdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ gdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
gdtrc(a,b,x) returns the integral from x to infinity of the gamma
probability density function:
inf
b -
a | | b-1 -at
y = ----- | t e dt
- | |
| (b) -
x
The incomplete gamma integral is used, according to the relation
y = igamc( b, ax ).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions ndtr
≡functions ndtr
≡ndtr
┌──────────────────────────────────────────────────────────────────────┐
│ ndtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
ndtr(x) returns the area under the Gaussian probability density
function, integrated from minus infinity to x:
x
-
1 | | 2
ndtr(x) = --------- | exp( - t /2 ) dt
sqrt(2pi) | |
-
-inf
= ( 1 + erf(z) ) / 2
= erfc(z) / 2
where z = x/sqrt(2). Computation is via the functions erf and erfc.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions ndtri
≡functions ndtri
≡ndtri
┌──────────────────────────────────────────────────────────────────────┐
│ ndtri │
└──────────────────────────────────────────────────────────────────────┘
Description:
ndtri(y) returns the argument, x, for which the area under the Gaussian
probability density function (integrated from minus infinity to x) is
equal to y.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions pdtr
≡functions pdtr
≡pdtr
┌──────────────────────────────────────────────────────────────────────┐
│ pdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
pdtr(k,m) returns the sum of the first k terms of the Poisson
distribution:
k j
-- -m m
> e --
-- j!
j=0
The terms are not summed directly; instead the incomplete gamma integral
is employed, according to the relation
y = pdtr( k, m ) = igamc( k+1, m ).
The arguments must both be positive.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions pdtrc
≡functions pdtrc
≡pdtrc
┌──────────────────────────────────────────────────────────────────────┐
│ pdtrc │
└──────────────────────────────────────────────────────────────────────┘
Description:
pdtrc(k,m) returns the sum of the terms k+1 to infinity of the Poisson
distribution:
inf j
-- -m m
> e --
-- j!
j=k+1
The terms are not summed directly; instead the incomplete gamma integral
is employed, according to the formula
y = pdtrc( k, m ) = igamma( k+1, m ).
The arguments must both be positive.
Also see FUNCTIONS and PROBABILITY.
≡expressions functions pdtri
≡functions pdtri
≡pdtri
┌──────────────────────────────────────────────────────────────────────┐
│ pdtri │
└──────────────────────────────────────────────────────────────────────┘
Description:
pdtri(k,y) finds the Poisson variable x such that the integral from
0 to x of the Poisson density is equal to the given probability y.
This is accomplished using the inverse gamma integral function and
the relation m = igami( k+1, y ).
Also see FUNCTIONS and PROBABILITY.
≡expressions functions stdtr
≡functions stdtr
≡stdtr
┌──────────────────────────────────────────────────────────────────────┐
│ stdtr │
└──────────────────────────────────────────────────────────────────────┘
Description:
stdtr(k,t) computes the integral from minus infinity to t of the Student
t distribution with integer k > 0 degrees of freedom:
t
-
| |
- | 2 -(k+1)/2
| ( (k+1)/2 ) | ( x )
---------------------- | ( 1 + --- ) dx
- | ( k )
sqrt( k pi ) | ( k/2 ) |
| |
-
-inf
Relation to incomplete beta integral:
1 - stdtr(k,t) = 0.5 * ibeta( k/2, 1/2, z )
where
z = k/(k + t**2).
Also see FUNCTIONS and PROBABILITY.
≡bessel
┌──────────────────────────────────────────────────────────────────────┐
│ Bessel Functions │
└──────────────────────────────────────────────────────────────────────┘
Description:
Bessel functions arise in solving differential equations for systems
with cylindrical symmetry.
Jn(x) is often called the Bessel function of the first kind, or simply
the Bessel function. Yn(x) is referred to as the Bessel function of
the second kind, the Weber function, or the Newmann function. In(x)
and Kn(x) are modified Bessel functions. They are equivalent to the
usual Bessel functions Jn and Yn evaluated for purely imaginary
arguments.
Twelve Bessel functions are provided with Graphica: besi0, besi1,
besin, besj0, besj1, besjn, besk0, besk1, beskn, besy0, besy1 and besyn.
All Bessel functions expect x to be in radians.
besi0(x) returns the 0th (modified) Bessel function I. besi1(x)
returns the 1st (modified) Bessel function I. besin(n,x) returns the
nth (modified) Bessel function I, where n > 1.
besj0(x) returns the 0th Bessel function J. besj1(x) returns
the 1st Bessel function J. besjn(n,x) returns the nth Bessel
function J, where n > 1.
besk0(x) returns the 0th (modified) Bessel function K. besk1(x)
returns the 1st (modified) Bessel function K. beskn(n,x) returns the
nth (modified) Bessel function K.
besy0(x) returns the 0th Bessel function Y. besy1(x) returns
the 1st Bessel function Y. besyn(n,x) returns the nth (modified)
Bessel function Y, where n > 1.
Also see BESI0, BESI1, BESIN, BESJ0, BESJ1, BESJN, BESK0, BESK1, BESKN,
BESY0, BESY1, and BESYN for more details.
≡expressions functions besi0
≡functions besi0
≡besi0
┌──────────────────────────────────────────────────────────────────────┐
│ besi0 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besi0(x) returns the i0th (modified) Bessel function of x, where x
is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besi1
≡functions besi1
≡besi1
┌──────────────────────────────────────────────────────────────────────┐
│ besi1 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besi1(x) returns the i1st (modified) Bessel function of x, where x
is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besin
≡functions besin
≡besin
┌──────────────────────────────────────────────────────────────────────┐
│ besin │
└──────────────────────────────────────────────────────────────────────┘
Description:
besin(n,x) returns the inth (modified) Bessel function of x, where x
is in radians and n > 1.
Also see BESSEL and FUNCTIONS.
≡expressions functions besj0
≡functions besj0
≡besj0
┌──────────────────────────────────────────────────────────────────────┐
│ besj0 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besj0(x) returns the j0th Bessel function of x, where x is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besj1
≡functions besj1
≡besj1
┌──────────────────────────────────────────────────────────────────────┐
│ besj1 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besj1(x) returns the j1st Bessel function of x, where x is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besjn
≡functions besjn
≡besjn
┌──────────────────────────────────────────────────────────────────────┐
│ besjn │
└──────────────────────────────────────────────────────────────────────┘
Description:
besjn(n,x) returns the jnth Bessel function of x, where x is in
radians and n > 1.
Also see BESSEL and FUNCTIONS.
≡expressions functions besk0
≡functions besk0
≡besk0
┌──────────────────────────────────────────────────────────────────────┐
│ besk0 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besk0(x) returns the k0th (modified) Bessel function of x, where x
is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besk1
≡functions besk1
≡besk1
┌──────────────────────────────────────────────────────────────────────┐
│ besk1 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besk1(x) returns the k1st (modified) Bessel function of x, where x
is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions beskn
≡functions beskn
≡beskn
┌──────────────────────────────────────────────────────────────────────┐
│ beskn │
└──────────────────────────────────────────────────────────────────────┘
Description:
beskn(n,x) returns the knth (modified) Bessel function of x, where x
is in radians and n > 1.
Also see BESSEL and FUNCTIONS.
≡expressions functions besy0
≡functions besy0
≡besy0
┌──────────────────────────────────────────────────────────────────────┐
│ besy0 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besy0(x) returns the y0th Bessel function of x, where x is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besy1
≡functions besy1
≡besy1
┌──────────────────────────────────────────────────────────────────────┐
│ besy1 │
└──────────────────────────────────────────────────────────────────────┘
Description:
besy1(x) returns the y1st Bessel function of x, where x is in radians.
Also see BESSEL and FUNCTIONS.
≡expressions functions besyn
≡functions besyn
≡besyn
┌──────────────────────────────────────────────────────────────────────┐
│ besyn │
└──────────────────────────────────────────────────────────────────────┘
Description:
besyn(n,x) returns the ynth (modified) Bessel function of x, where x
is in radians and n > 1.
Also see BESSEL and FUNCTIONS.
≡environment
┌──────────────────────────────────────────────────────────────────────┐
│ Environment Variables │
└──────────────────────────────────────────────────────────────────────┘
An environment variable is used to specify from the operating system
certain parameters of program operation. The "environment" is really
just a common area of memory that programs can write to and read from.
Some programs are geared to look specifically at the environment to find
particular data important to their operation. They may ask you to place
a variable into the environment equal to a certain value so that they
can find support files which could not be found otherwise.
A number of shell environment variables are understood by Graphica.
None of these are required, but may be useful:
- GRAPTERM
- GRAPDUMP
- GRAPHELP
- GRAPHINI
- GRAPFONT
GRAPTERM may be used as the name of the terminal type to be used. This
overrides any terminal type sensed by Graphica on start up, but is itself
overridden by the 'graphica.ini' or other start-up file, and of course by
later explicit changes.
GRAPDUMP is used as the default terminal type used when dumping graphics
to a file.
GRAPHELP may be defined to be the pathname of the help file. If this
environment variable is not defined, Graphica will try to look for the
help file somewhere in your DOS path. If the help file can't be found,
you have no on-line help available.
GRAPHINI may be used as the pathname of a startup-up file. The default
name is 'graphica.ini' on DOS/VAX systems and '.graphica' on UNIX. The
DOS version of Graphica will use the entire search path to look for it.
GRAPFONT specifies where Graphica's font files are located. If the
font files are not somewhere in your DOS path, you may specify an
environment variable called GRAPFONT containing the font directory.
For example, if the fonts are in C:\GRAPHICA\FONTS, then you would
specify,
SET GRAPFONT=C:\GRAPHICA\FONTS
somewhere in your autoexec.bat file or in a batch file just before
running Graphica. Graphica will then find the necessary font file
in that directory and load it at runtime.
DOS Environment Variables
-------------------------
If we were to look at the DOS environment (by typing the SET command
at the DOS prompt), we might see a listing similar to the one below:
COMSPEC=C:\COMMAND.COM
PATH=C:\;C:\DOS;C:\UTIL
Other values might be present, like PROMPT=$P$G, and more depending
on the types and kinds of software you are running.
Environment variables are specified before running Graphica. They
can be specified directly from DOS, from within the AUTOEXEC.BAT file,
or from within any batch file.
The command for setting an environment variable is:
SET PARAMETER=PARAMETER VALUE
Examples:
C:\SET GRAPDUMP=hpgl (sets the dump terminal type)
C:\SET GRAPHELP=c:\plot\graphica.hlp (the help file)
C:\SET GRAPHINI=c:\plot\graphica.ini (the start-up file)
C:\SET GRAPFONT=C:\GRAPHICA\FONT (font files)
In general, you won't have to set the DOS environment variable GRAPTERM if
you have any of the commonly available graphics monitors, CGA/EGA/VGA, etc.
Unix Shell Variables
--------------------
In a UNIX environment, things get a little bit confusing because of the
different shells that you might be running. Environment variables can
be shown by using the 'printenv' command (Korn-shell or /bin/sh), the
'setenv' command (c-shell or /bin/csh) or the 'AEGIS' command (Aegis
shell on Apollos). To set them, do
$ GRAPTERM=apollo
$ GRAPDUMP=postscript
$ export GRAPDUMP
$ export GRAPTERM
Also see STARTUP.
≡startup
┌──────────────────────────────────────────────────────────────────────┐
│ Startup File │
└──────────────────────────────────────────────────────────────────────┘
When Graphica is run, it looks for an initialization file to load.
This file is called 'graphica.ini'. If this file is not found in the
current directory (or entire search path on DOS systems), the program
will look for a start-up file pointed to by the environment variable
GRAPHINI.
If the initialization file is found, Graphica executes the commands
in that file. This is most useful for setting your terminal type and
defining any functions or variables which you use often.
Also see ENVIRONMENT.
≡text
┌──────────────────────────────────────────────────────────────────────┐
│ Text Primitives │
└──────────────────────────────────────────────────────────────────────┘
Text primitives generate a string of characters on a display device
in a specific location in the world coordinate system. The character
string may comprise letters, numerals, and symbols. Text primitives
provide a method for labeling and clarifying a graphical image.
This section describes the control sequences which are accessible
when specifying a string label. The control sequences are only available
when using a software generated font. Graphica recognizes \ as a special
character used to signal the start of an escape sequence. There are two
kinds of escape sequences, those that take an argument and those that do
not.
The two escape sequences that do not take an argument are:
\U move up half a character size
\D move down half a character size
The following take one integer argument immediately after the escape
sequence and a space after it to delineate the end (the space is not
printed):
\Cn set color to n
\C-1 reset color to the default
\Fn set font to n
\F-1 reset font to the default
\Sn set character size to n % of the default size
\S-1 reset character size to the default size
\Ln set character slant to n degrees
\L-1 reset character slant to the default slant
\An print ascii n
\rn save current position in register n
\Rn restore position from register n
Examples:
to print greek characters such as in 'beta = x + lambda':
» label '\F2 b\F1 = x + \F2 l'
to label the x-axis with 'velocity U sub f':
» xlabel 'velocity, U\Dsub'
to place a top label of 'stress in dynes per cm squared':
» top label 'stress (dyn\cm\U2\D)'
to get 'x squared plus y squared':
» label 'x\U2\D + y\U2'
and finally, an advanced example. To get 'A sub b sup beta':
» label 'A\r1 \Db\R1 \U\F2 b'
This last example is translated as: do A, save this spot, go down half,
do b, restore the saved spot, go up half, switch to font 2 (greek simplex),
do beta. Notice the use of registers to stack characters on top of each
other.
To get a backslash, simply use one \.
≡version
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ version │
└──────────────────────────────────────────────────────────────────────┘
Description:
The 'version' command displays:
- your Graphica version number
- pertinent copyright and other information
Also on DOS systems:
- the amount of system RAM available
- the amount of disk space available in the current drive
≡what
Syntax:
┌──────────────────────────────────────────────────────────────────────┐
│ what │
└──────────────────────────────────────────────────────────────────────┘
Description:
'what' shows a directory listing of the .plt files on the disk in the
current directory. Files with other extensions are not shown.
Also see DEL, DIR, SHELL and TYPE.
≡wait
≡nowait
┌──────────────────────────────────────────────────────────────────────┐
│ wait │
│ nowait │
└──────────────────────────────────────────────────────────────────────┘
These commands toggle a flag which, when set, will make Graphica wait
until you press any key after the last plot appears on the screen. In
batch mode (or when 'term' is not a display mode) this command will not
any effect.
≡tips
┌──────────────────────────────────────────────────────────────────────┐
│ Tips │
└──────────────────────────────────────────────────────────────────────┘
Here some tips to help you get started with Graphica:
- Pressing any key while the introductory screen is shown will turn
it off and take you directly to the command line.
- Use the arrow keys (up, down, right, left ) to recall previous
commands or edit the current command line.
- Type 'what' to get a list of all the *.plt script files you may
have in the current directory.
- You may put more than one command on a line--just separate each
command by a semicolon, for example,
» plot x y add ; column 3 is y ; plot x y connect
- Pressing F1 calls up the help system. Pressing F10 displays the
graph on the screen.
≡errors
┌──────────────────────────────────────────────────────────────────────┐
│ Errors │
└──────────────────────────────────────────────────────────────────────┘
When Graphica encounters an error caused by an incorrect command in a
script file or on the command line it will issue an error message. If
the bad command was in a script file, the line number will be given.
You can type SHOW at the command line to see everything you've plotted
so far. You can also correct errors in a script file by "shelling" out
to the OS or issue a $edit command (to invoke the editor from within
Graphica for example) where 'edit' is the name of your favorite editor.
≡bugs
┌──────────────────────────────────────────────────────────────────────┐
│ Bug Reports │
└──────────────────────────────────────────────────────────────────────┘
Graphica is under constant revision, updating and being given expanded
capabilities. Prior to each release, the developer strives to verify new
features and bug fixes through testing. However, as inevitably happens
with any software, some bugs do survive and show up in user runs. Users
can aid in the problem fixing process by following the guidelines below:
a) Report any unusual messages, computed results, format overflows,
etc. even though the program appears to have terminated normally.
b) For any abnormal program termination, save the input file and all
output obtained by running the program.
Reported problems will be fixed as quickly as possible. In most
instances, alternate methods or techniques of plot formulation and
input are available to permit graphing despite the bug. All problems
encountered with Graphica should be reported to:
┌──────────────────────────────────────────────────────────────────────┐
│ Antonio Montes Internet address: tony@amontes.oss.nl │
│ Postbus 13 CompuServe ID: 71031,1162 │
│ 2350 AA Leiderdorp │
│ The Netherlands │
└──────────────────────────────────────────────────────────────────────┘