Name: CURVE   10
CURVE connects  data points  with lines  or plots them with sym-
bols.
The call is:  CALL CURVE (XRAY, YRAY, N)              level 2, 3
         or:  void curve (const float *xray, const float *yray, 
                                                         int n);
XRAY, YRAY    are arrays that contain the X- and Y-coordinates.
N             is the number of data points.
Name: ERRBAR  10
The routine ERRBAR plots error bars.
The call is:  CALL ERRBAR (XRAY, YRAY, E1RAY, E2RAY, N)
                                                      level 2, 3
         or:  void errbar (const float *xray, const float *yray, 
                 const float *e1ray, const float *e2ray, int n);
XRAY, YRAY    are arrays that contain the X- and Y-coordinates.
              For  a polar scaling,  XRAY  must hold  the radial 
              values and  YRAY the  angular values  expressed in
              radians.
E1RAY, E2RAY  are arrays that contain the errors. Lines  will be
              drawn from YRAY - E1RAY to YRAY + E2RAY.
N             is the number of data points.
Notes:      - Horizontal bars  will be drawn  after  CALL BARTYP
              ('HORI').
            - A symbol can be selected with  MARKER and the sym-
              bol size with HSYMBL. 
Name: FIELD  10
The routine  FIELD  plots a vector field where the start and end
points  of  the  vectors  are  already  calculated.  The vectors
are displayed as arrows.
The call is:  CALL FIELD (X1RAY, Y1RAY, X2RAY, Y2RAY, N, IVEC)
                                                    - level 2, 3
         or:  void field(const float *x1ray, const float *x1ray, 
                         const float *x2ray, const float *y2ray, 
                                               int n, int ivec);
X1RAY, Y1RAY  are arrays that contain  the  X- and Y-coordinates
              of the start points. 
X2RAY, Y2RAY  are arrays that contain  the  X- and Y-coordinates
              of the end points. 
N             is the number of vectors.
IVEC          is a four  digit  number that specifies the vector
              (see VECTOR).
Name: VECFLD 10
The routine  VECFLD  plots  a vector field  of given vectors and
positions.The vectors are displayed as arrows.
The call is:  CALL VECFLD (XVRAY, YVRAY, XPRAY, YPRAY, N, IVEC)
                                                      level 2, 3
         or:  void vecfld (const float *xvray, 
                         const float *yvray, const float *xpray, 
                         const float *ypray, int n, int ivec);  
XVRAY, YVRAY  are arrays  that contain  the X- and Y-coordinates
              of the vectors. 
XPRAY, YPRAY  are arrays  that contain  the X- and Y-coordinates
              of the start points. 
N             is the number of vectors.
IVEC          is an integer  that specifies  the form of the ar-
              rows (see VECTOR).
Notes:      - The  length  of the arrows is automatically scaled
              by DISLIN  in the routine  VECFLD.  This behaviour
              can be changed  with the routine VECOPT,  that may
              also modify the appearance of arrows.
            - The vectors can be scaled  with different  colours
              if the routine  VECCLR  is called  before with the
              parameter -2. If VECFLD and FIELD are called after
              GRAF,  the  minimum  and  maximum  of  the  vector 
              lengths are used for colour scaling. If VECFLD and
              FIELD are  called after  GRAF3,  the Z-scaling  in
              GRAF3 is used for calculating colours.
Name: VECMAT 10
The routine VECMAT plots a vector field on a regular grid.
The call is:  CALL VECMAT (XVMAT, YVMAT, NX, NY, XPRAY, YPRAY,
                                      IVEC)           level 2, 3
         or:  void vecmat (const float *xvmat, 
                           const float *yvmat, int nx, int ny, 
                           const float *xpray, 
                           const float *ypray, int ivec);
XVMAT, YVMAT  are arrays of the dimension  (NX, NY) that contain
              the X- and Y-coordinates of the vectors. 
NX, NY        define the dimension of XVMAT and YVMAT. 
XPRAY, YPRAY  are arrays of the dimensions NX und NY that define
              the grid in the X/Y plane.
IVEC          is an  integer  that specifies the form of the ar-
              rows (see VECTOR).
Note:         See the notes for VECFLD.
Name: STREAM 10
The routine  STREAM  plots  streamlines  of a  vector field on a 
regular grid.
The call is:  CALL STREAM (XVMAT, YVMAT, NX, NY, XPRAY, YPRAY, 
                                     XSRAY, YSRAY, N) level 2, 3
         or:  void stream (const float *xvmat, 
                         const float *yvmat, int nx, int ny, 
                         const float *xpray, const float *ypray, 
                         const float *xsray, const float *ysray, 
                         int n);
XVMAT, YVMAT  are arrays of the dimension  (NX, NY) that contain
              the X- and Y-coordinates of the vectors. 
NX, NY        define the dimension of XVMAT and YVMAT. 
XPRAY, YPRAY  are arrays of the dimensions NX und NY that define
              the grid in the X/Y plane.
XSRAY, YSRAY  are arrays  of the dimension N that contain start-
              ing  points  of the  streamlines.  If  no starting
              points  are  given,  evenly-spaced streamlines are
              automatically plotted by DISLIN. 
N             is the number of statrting points (N >= 0).
Notes:      - The  integration method in  STREAM  can be changed
              with the routine STMMOD. By default, a Runge-Kutta
              2nd order method is used.
            - The behaviour of streamlines  can be modified with
              the routines STMOPT and STMVAL.
Name: STMPTS 10
The routine  STMPTS  returns a calculated streamline of a vector
field on a regular grid.
The call is:  CALL STMPTS (XVMAT, YVMAT, NX, NY, XPRAY, YPRAY, 
                         X0, Y0, XRAY, YRAY, NMAX, N) level 2, 3
         or:  void stmpts (const float *xvmat, 
                   const float *yvmat, int nx, int ny, 
                   const float *xpray, const float *ypray, 
                   float x0, float y0, float *xray, float *yray, 
                   int nmax, int *n);
XVMAT, YVMAT  are arrays of the dimension  (NX, NY) that contain
              the X- and Y-coordinates of the vectors. 
NX, NY        define the dimension of XVMAT and YVMAT. 
XPRAY, YPRAY  are arrays of the dimensions NX und NY that define
              the grid in the X/Y plane.
X0, Y0        define the starting point.
XRAY, YRAY    are arrays of the dimension NMAX that will contain
              the calculated streamline.
NMAX          is the dimension of XRAY and YRAY.
N             is the returned number of points in XRAY and YRAY.
Note:         See the notes for STREAM.
Name: STMTRI 10
The routine  STMTRI  plots  streamlines of a  vector  field on a
triangular grid.
The call is:  CALL STMTRI (XVRAY, YVRAY, XPRAY, YPRAY, N, I1RAY,
                 I2RAY, I3RAY, NTRI, XSRAY, YSRAY, NRAY)
                                                      level 2, 3
         or:  void stmtri (const float *xvray, 
                 const float *yvray, const float *xpray, 
                 const float *ypray, int n, const int *i1ray, 
                 const int *i2ray, const int *i3ray, in ntri,
                 const float *xsray, const float *ysray, 
                 int nray);
XVRAY, YVRAY  are arrays  of the dimension N that contain the X- 
              and Y-coordinates of the vectors. 
XPRAY, YPRAY  are arrays  of the  dimension  N that contain  the
              positions of the vectors.
N             is the number of vectors.
I1RAY, I2RAY, is a  triangulation  of  the points in  XPRAY  and
   I3RAY      YPRAY. 
NTRI          is the  number  of triangles in  I1RAY,  I2RAY and
              I3RAY.
XSRAY, YSRAY  are  arrays  of the  dimension  NRAY that  contain 
              starting points of the streamlines. If no starting
              points  are given,  evenly-spaced  streamlines are 
              automatically plotted by DISLIN. 
NRAY          is the number of starting points (NRAY >= 0).
Name: LICPTS 10
The routine  LICPTS  calculates a  Line Integral Convolution
(LIC) image of a vector field.
The call is:  CALL LICPTS (XVMAT, YVMAT, NX, NY, ITMAT, IWMAT,
                           WMAT)                   level 1, 2, 3
         or:  void licpts (const float *xvmat, 
                     const float *yvmat, int nx, int ny, 
                     const int *itmat, int *iwmat, float *xmat);
XVMAT, YVMAT  are arrays of the dimension  (NX, NY) that contain
              the X- and Y-coordinates of the vectors. 
NX, NY        define the dimension of XVMAT, YVMAT, ITMAT, IWMAT
              and WMAT. 
ITMAT         is a texture array  of the dimension (NX, NY) that
              is used for  the LIC algorithm.  A random  texture
              can be calculated with the routine TXTURE.
IWMAT         is a  working  array  of the  dimension  (NX, NY). 
              After the call to LICPTS,  IWMAT contains the num-
              ber of  hits  for image pixels  covered by stream-
              lines. 
WMAT          is an  output array of the dimension (NX, NY) that
              contains  the calculated LIC image.  WMAT contains
              floating point  numbers between 0 and 255.
Notes:      - LICPTS  uses by default a fast LIC algorithm based
              on an idea  by Detlev Stalling  and Hans-Christian 
              Hege.  Some  parameters  of the fast LIC algorithm
              can be modified with the routines  LICMOD,  STMOPT
              and STMVAL.
            - The calculated LIC image can be plotted for examp-
              le with the routine CRVMAT.
Name: TXTURE 10
The routine  TXTURE generates a random texture array that can be
passed to the routine LICPTS.
The call is:  CALL TXTURE (ITMAT, NX, NY)      level 1, 2, 3
         or:  void txture (int *itmat, int nx, int ny);
ITMAT         is a returned  texture array of the dimension (NX,
              NY). ITMAT contains random numbers in the  range 0
              to 255. 
NX, NY        define the dimension of ITMAT.
Note:         DISLIN uses the MINSTD random number generator  of
              S.K. Park  and K.W. Miller for calculating  random
              numbers.  The returned  array is identical for all
              DISLIN distributions.
Name: LEGINI  11
LEGINI initializes a legend.
The call is:  CALL LEGINI (CBUF, NLIN, NMAXLN)     level 1, 2, 3
         or:  void legini (char *cbuf, int nlin, int nmaxln);
CBUF          is a character variable used to store the lines of
              text in the legend.  The variable must be declared
              to have at least NLIN * NMAXLN characters.
NLIN          is the number of text lines in the legend (<= 80).
NMAXLN        is the number of characters in the longest line of
              text (<= 132).
Name: LEGLIN  11
LEGLIN stores lines of text for the legend.
The call is:  CALL LEGLIN (CBUF, CSTR, ILIN)       level 1, 2, 3
         or:  void leglin (char *cbuf, char *cstr, int nlin);
CBUF          is a character variable used to store the lines of
              text in the legend (see LEGINI).
CSTR          is a character string that contains a line of text
              for the legend.
ILIN          is the  number  of the  legend line  between 1 and
              NLIN.
Name: LEGEND  11
LEGEND plots the legend.
The call is:  CALL LEGEND (CBUF, NCOR)                level 2, 3
         or:  void legend (const char *cbuf, int ncor);
CBUF          is a character variable used to store the lines of
              text in the legend (see LEGINI).
NCOR          indicates the position of the legend:
       =  1   is the lower left  corner of the page.
       =  2   is the lower right corner of the page.
       =  3   is the upper right corner of the page.
       =  4   is the upper left  corner of the page.
       =  5   is the lower left  corner of the axis system.
       =  6   is the lower right corner of the axis system.
       =  7   is the upper right corner of the axis system.
       =  8   is the upper left  corner of the axis system.
       =  9   means the left side centered  at the middle of the
              page.
       = 10   means the right side centered at the middle of the
              page.
Name: LEGTIT  11
LEGTIT sets the legend title.
The call is:  CALL LEGTIT (CTIT)                   level 1, 2, 3
         or:  void legtit (const char *ctit);
CTIT          is a character string containing the title
              (<= 132 characters).
                                      Default: CTIT = 'Legende'.
Name: LEGPOS  11
LEGPOS  defines a global position for the legend.  After  a call
to LEGPOS, the second parameter in LEGEND will be ignored.
The call is:  CALL LEGPOS (NX, NY)                 level 1, 2, 3
         or:  void legpos (int nx, int ny);
NX, NY        are the plot coordinates of the upper left corner.
Name: NXLEGN  11
NXLEGN returns the length of the legend in plot coordinates.
The call is:  NLX = NXLEGN (CBUF)                  level 1, 2, 3
         or:  int   nxlegn (const char *cbuf);
CBUF          see LEGINI
Name: NYLEGN  11
NYLEGN returns the height of the legend in plot coordinates.
The call is:  NLY = NYLEGN (CBUF)                  level 1, 2, 3
         or:  int   nylegn (const char *cbuf);
CBUF          see LEGINI
Name: MIXLEG  11
The routine  MIXLEG enables multiple text lines in legends plot-
ted with the routine LEGEND.  By default,  the character  '/' is
used as a newline character  but can be changed with the routine
SETMIX.
The call is:  CALL MIXLEG                          level 1, 2, 3
         or:  void mixleg ();
Name: LEGBGD  11
LEGBGD sets the background colour of legends.
The call is:  CALL LEGBGD (NCLR)                   level 1, 2, 3
         or:  void legbgd (int nclr);
NCLR          is a colour value.  If NCLR = -1,  the plotting of
              the background is suppressed.
                                             Default: NCLR = -1.
Name: LEGCLR  11
LEGCLR retains the same colour for curves and text in legends.
The call is:  CALL LEGCLR                          level 1, 2, 3
         or:  void legclr ();
Name: LEGPAT  11
The routine  LEGPAT  stores curve attributes plotted in legends.
Normally,  this is done automatically by routines such as  CURVE
and BARS.
The call is:  CALL LEGPAT (ITYP, ITHK, ISYM, ICLR, IPAT, ILIN)
                                                   level 1, 2, 3 
         or:  void legpat (int ityp, int ithk, int isym, 
                           int iclr, long ipat, int ilin);
ITYP          is the line style between -1 and 7 (see LINTYP).
              IF ITYP = -1, no line will be plotted in  the  le-
              gend line.
ITHK          define the thickness of lines (> 0).
ISYM          is the symbol number between -1 and 21.  If ISYM =
              -1, no symbol will be plotted in the legend line.
ICLR          is  the colour  value.  If ICLR = -1,  the current
              colour will be used.
IPAT          is the shading pattern (see SHDPAT). If IPAT = -1,
              no pattern will be plotted in the legend line.
ILIN          is the legend line between 1 and NLIN.
Notes:      - This routine is useful  to create legends  without
              calls to CURVE.
            - LEGPAT must be called after LEGINI.
Name: LEGTYP  11
Legend  entries can be plotted in  vertical or horizontal direc-
tion or in table form  depending  on the option in  LEGTYP.  The
routine must be called before LEGINI.
The call is:  CALL LEGTYP (COPT)                   level 1, 2, 3
         or:  void legtyp (const char *copt);
COPT          is a  character  string  that can have  the values
              'VERT', 'HORI' and 'TABLE'.       Default: 'VERT'.
Name: LEGTBL  11
This routine defines the number of  columns in table legends and
the direction in which the legend entries are plotted.
The call is:  CALL LEGTBL (N, COPT)                level 1, 2, 3
         or:  void legtbl (int n, const char *copt);
N             is the number of columns.
COPT          is a character  string  that  can  have the values
              'VERT' and 'HORI'.           Default: (3, 'VERT').
Name: LEGOPT  11
This routine modifies the appearance of legends.
The call is:  CALL LEGOPT (XF1, XF2, XF3)          level 1, 2, 3
         or:  void legopt (float xf1, float xf2, float xf3);
XF1           is a  multiplier  for the  length  of the  pattern
              field.  The length is  XF1 * NH,  where NH  is the
              current character height. If XF1 = 0., the pattern
              field will be suppressed.
XF2           is a  multiplier  for the  distance between legend
              frames and text.  The distance is XF2 * NH * XSPC,
              where  XSPC  is the  spacing  between legend lines
              (see LINESP).
XF3           is a multiplier for the  spacing between  multiple
              text lines. The space is XF3 * NH * XSPC.
                                       Default: (4.0, 0.5, 1.0).  
Name: LEGVAL  11
The routine LEGVAL modifies the appearance of legends.
The call is:  CALL LEGVAL (X, COPT)                level 1, 2, 3
         or:  void legval (float x, const char *copt); 
COPT          is a  character  string  that can have the values:
'PATTERN'     sets the length of the  pattern  field to  X * NH,
              where NH is the current charater size.
'MARGIN'      sets the margin between  legend  frame and text to
              X * NH * XLINSP,  where XLINSP is the current line
	      space.
'LINE'        sets the spacing between  multiple  text lines  to
              X * NH * XLINSP.
'SYMBOL'      defines the size of symbols with X * NH.
'HSPACE'      sets the space between  legend  columns to X * NH.
'DISTANCE'    sets the horizontal space between the  pattern and
              the text fields to X * NH.
                   Defaults: (4.0, 'PATTERN'), (0.5, 'MARGIN'),
		             (1.0, 'LINE'), (0.8, 'SYMBOL'),
                             (2.0, 'HSPACE'), (1.0, 'DISTANCE').
Notes:      - If X has a negative value,  it's positive value is
              interpreted as plot units and not as a multiplier.
            - LEGVAL should be called after LEGINI.
Name: LEGSEL  11
The routine  LEGSEL  selects  legend  lines  that are plotted by
LEGEND.
The call is:  CALL LEGSEL (IRAY, N)                level 1, 2, 3
         or:  void legsel (int *iray, int n);
IRAY          is an  integer  array that  contains  legend lines 
              between 1 and NLIN, where NLIN is the parameter in
              LEGINI.
N             is the number of elements in IRAY.  If N = -1, all
              legend lines are plotted. 
                                                 Default: N = -1
Name: LINFIT  10
LINFIT plots a straight line that has the  best  fit to a series
of data points.
The call is:  CALL LINFIT (XRAY, YRAY, N, A, B, R, COPT)      
                                                      Level 2, 3
         or:  void linfit (float *xray, float *yray, int n,
                      float *a, float *b, float *r, char *copt);
XRAY, YRAY    are arrays that contain X- and Y-coordinates.
N             is the number of data points.
A, B          are the returned values of the calculated line
              Y = A * X + B.
R             is the returned correlation coefficient of the fit
              between -1.0 and 1.0. A value around zero means no
              correlation, a value near  -1.0 or 1.0  means good
              correlation.
COPT          is a character  string  that can  have the  values
              'NONE',  'ALL' and 'LINE'. 'NONE' means that  just
              the values  A, B and R are calculated.  Nothing is
              plotted.  For that case  LINFIT can also be called
              in  the  levels  0 and 1.  'LINE' means  that  the
              straight  line  is  plotted  and  'ALL'  that  the 
              straight line and the data points are plotted.  
Name: SHDCRV  10
SHDCRV plots a shaded area between two curves.        level 2, 3
The call is:  CALL SHDCRV (X1RAY, Y1RAY, N1, X2RAY, Y2RAY, N2)
         or:  void shdcrv (const float *x1ray, 
                         const float *y1ray, int n1,
                         const float *x2ray, const float *y2ray,
                         int n2);
X1RAY, Y1RAY  are arrays with the  X- and  Y-coordinates  of the
              first curve. Values will not changed by SHDCRV.
N1            is the number of points in the first curve.
X2RAY, Y2RAY  are arrays with the  X- and  Y-coordinates  of the
              second curve. Values will not changed by SHDCRV.
N2            is the number of points in the second curve.
