Name: AXIS3D  23
The routine AXIS3D defines the lengths of the 3-D box.  For  the
lengths, any positive  values can be specified; DISLIN uses only
the ratio of the values to calculate the axis lengths.
The call is:  CALL AXIS3D (X3AXIS, Y3AXIS, Z3AXIS) level 1, 2, 3
         or:  void axis3d (float x3axis, float y3axis, 
                                                  float z3axis);
X3AXIS        is the length of the  X-axis in absolute 3-D coor-
              dinates (> 0).
Y3AXIS        is the length of the  Y-axis in absolute 3-D coor-
              dinates (> 0).
Z3AXIS        is the length of the  Z-axis in absolute 3-D coor-
              dinates (> 0).
                                           Default: (2., 2., 2.)
Note:         The lower left corner of the 3-D box is the  point
              (-X3AXIS/2, -Y3AXIS/2, -Z3AXIS/2); the upper right
              corner is the point (X3AXIS/2, Y3AXIS/2, Z3AXIS/2)
              The centre point is (0., 0., 0.).
Name: VIEW3D  23
The routine VIEW3D defines the viewpoint.
The call is:    CALL VIEW3D (XVU, YVU, ZVU, CVU)   level 1, 2, 3
         or:    void view3d (float xvu, float yvu, float zvu,
                                                     char *cvu);
XVU, YVU, ZVU   define the position  of the viewpoint.  If CVU =
                'ABS', the parameters must contain  absolute 3-D
                coordinates, if CVU = 'USER', they must  contain
                user coordinates and if CVU = 'ANGLE', the view-
                point must be specified by two angles  and a ra-
                dius.  In the  latter case,  XVU  is a  rotation
                angle,  YVU is the  angle  between the line from
                the  viewpoint  to the centre of the 3-D box and
                the horizontal direction and ZVU is the distance
                of the viewpoint from the centre of the 3-D box.
                XVU and YVU must be specified in degrees and ZVU
                in absolute 3-D coordinates.
CVU             is a  character string  defining  the meaning of
                XVU, YVU and ZVU.
                Def.:  (2*X3AXIS, -2.5*Y3AXIS, 2*Z3AXIS, 'ABS').
Note:           The viewpoint  must be  placed  outside the  3-D
                box. If the point lies inside, DISLIN will print
                a warning and use the default viewpoint.
Name: GRAF3D  23
The routine  GRAF3D plots a three-dimensional axis system.  This
routine must be called  before any objects can be plotted in the
3-D box.
The call is:  CALL GRAF3D (XA, XE, XOR, XSTEP, YA, YE, YOR, 
                           YSTEP, ZA, ZE, ZOR, ZSTEP)    level 1
         or:  void graf3 (
                    float xa, float xe, float xor, float xstep,
                    float ya, float ye, float yor, float ystep,
                    float za, float ze, float zor, float zstep); 
XA, XE        are the lower and upper limits of the X-axis.
XOR, XSTEP    are the first  X-axis label  and the step  between
              labels.
YA, YE        are the lower and upper limits of the Y-axis.
YOR, YSTEP    are the first  Z-axis label  and the step  between
              labels.
ZA, ZE        are the lower and upper limits of the Z-axis.
ZOR, ZSTEP    are the first  Z-axis label  and the step  between
              labels.
Notes:      - GRAF3D must  be called  from  level 1 and sets the
              level to 3.
            - To avoid overwriting labels, GRAF3D suppresses the
              plotting of certain start labels.  This option can
              be disabled with the statement CALL FLAB3D.
            - The user is referred to the notes on GRAF.
Name: FLAB3D  23
To avoid overwriting labels,  GRAF3D suppresses  the plotting of
certain start labels.  This option can be be disabled with FLAB-
3D.
The call is:   CALL FLAB3D                         level 1, 2, 3
         or:   void flab3d ();
Name: CURV3D  23
The routine CURV3D is similar to  CURVE and connects data points
with lines or marks them with symbols.
The call is:  CALL CURV3D (XRAY, YRAY, ZRAY, N)          level 3
         or:  void curv3d (float *xray, float *yray,
                                            float *zray, int n);
XRAY          is an array  containing the  X-coordinates of data
              points.
YRAY          is an array  containing the  Y-coordinates of data
              points.
ZRAY          is an array  containing the  Z-coordinates of data
              points.
N             is the number of data points.
Note:         Data points  will be  interpolated  linearly.  The
              user is referred to the notes on CURVE.
Name: SURFUN  23
The routine  SURFUN  plots  a surface  of the  three-dimensional
function Z = F(X,Y).
The call is: CALL SURFUN (ZFUN, IXP, XDEL, IYP, YDEL)    level 3
         or: void surfun (float (*zfun)(), int ixp, float xdel, 
                                           int iyp, float ydel);
ZFUN         is the name of a  FUNCTION subroutine  that returns
             the function value for a given X- and Y-coordinate.
             ZFUN must be declared  EXTERNAL in the calling pro-
             gram.
XDEL, YDEL   are the distances  between grid lines in user coor-
             dinates. XDEL and YDEL determine the density of the
             surface plotted by SURFUN.
IXP, IYP     are the number of  points between grid lines inter-
             polated by SURFUN (>= 0). If IXP = 0, surface lines
             in the X-direction will be suppressed;  if IYP = 0,
             surface lines  in the Y-direction  will be suppres-
             sed.
Name: SURMAT  23
The routine  SURMAT  plots  a  surface  of the three-dimensional
function Z = F(X,Y).  The function values  must be  given in the
form of a matrix.
The call is:  CALL SURMAT (ZMAT, IXDIM, IYDIM, IXPTS, IYPTS)
                                                         level 3
         or:  void surmat (float *zmat[], int ixdim, int iydim,
                                          int ixpts, int iypts);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
IXPTS, IYPTS  are the number of points interpolated between grid
              lines in the X- and  Y-direction. These parameters
              determine the density  of surfaces plotted by SUR-
              MAT.  For positive  values,  the surface  will  be
              interpolated linearly.  For a negative value,  the
              absolute  value will be used as a step for plotted
              surface lines.  If IXPTS = 0, surface lines in the
              Y-direction will be suppressed; if IYPTS = 0, sur-
              face lines in the X-direction will be suppressed.
Notes:      - The suppression of  hidden lines  can be  disabled
              with CALL NOHIDE.
            - Surfaces can be  protected from  overwriting  with
              CALL SHLSUR  if the hidden-line  algorithm  is not
              disabled.
            - If XA, XE, YA and YE are the axis limits in GRAF3D
              or defined with the routine SURSZE, the connection
              of  grid points and matrix elements can be descri-
              bed by the formula: ZMAT(I,J) = F(X,Y) where

                    X = XA + (I - 1) * (XE - XA) / (IXDIM - 1),
                                                 I = 1,..,IXDIM 
                    Y = YA + (J - 1) * (YE - YA) / (IYDIM - 1),
                                                 J = 1,..,IYDIM.
Name: SHLSUR  23
Surfaces  can be  protected  from  overwriting  with the routine
SHLSUR if the hidden-line algorithm is not disabled.
The call is:  CALL SHLSUR                          level 1, 2, 3
         or:  void shlsur ();
Name: SURFCE  23
The routine  SURFCE  plots  a  surface  of the three-dimensional
function  Z = F(X,Y).  This routine  can be used with non linear
grids.
The call is:  CALL SURFCE (XRAY, IXDIM, YRAY, IYDIM, ZMAT)
                                                         level 3
         or:  void surfce (float *xray, int ixdim, float *yray,
                                      int iydim, float *zmat[]);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
XRAY, YRAY    are arrays  containing the X- and Y-user coordina-
              tes.
Name: SURSHD  23
The routine  SURSHD  plots  a  coloured  surface  of the  three-
dimensional function Z = F(X,Y). 
The call is:  CALL SURSHD (XRAY, IXDIM, YRAY, IYDIM, ZMAT)
                                                         level 3
         or:  void surshd (float *xray, int ixdim, float *yray,
                                      int iydim, float *zmat[]);
ZMAT          is a matrix with the dimension (IXDIM, IYDIM) con-
              taining the function values.
IXDIM, IYDIM  are the dimensions of ZMAT, XRAY and YRAY (>= 2).
XRAY, YRAY    are arrays  containing the X- and Y-user coordina-
              tes.
Note:         Colour values are calculated from the Z-scaling in
              the routine  GRAF3D or from the  parameters of the
              routine ZSCALE. 
Name: ZSCALE  23
The routine  ZSCALE  defines a Z-scaling  that will be used from
the routine SURSHD to calculate colour values.
The call is:  CALL ZSCALE (ZMIN, ZMAX)             level 1, 2, 3
         or:  void zscale (float zmin, float zmax);
ZMIN, ZMAX    are minimum  and maximum  of the Z-scaling in user
              coordinates.  For a logarithmic scaling, the para-
              meters must be exponents of base 10.
Name: NOHIDE  23
The routine NOHIDE disables the hidden-line algorithm.
The call is   CALL NOHIDE                          level 1, 2, 3
         or:  void nohide ();
Name: SURVIS  23
This routine defines the visible part of an surface.
The call is:  CALL SURVIS (CVIS)                   level 1, 2, 3
         or:  void survis (char *cvis);
CVIS          is a character  string  that  can have  the values
              'TOP', 'BOTTOM', and 'BOTH'. 
                                         Default: CVIS = 'BOTH'.
Name: SURCLR  23
The routine SURCLR defines colours for  the upper and lower side
of a surface.
The call is:  CALL SURCLR (ICTOP, ICBOT)           level 1, 2, 3
         or:  void surclr (int ictop, int icbot);
ICTOP, ICBOT  are colour numbers in the range -1 to 255. For the
              value -1, the current colour will be used.
                                              Default: (-1, -1).
Name: SURSZE  23
The limits of  the base grid used  for surfaces and contours can
be altered with the routine SURSZE.  By default, the scaling va-
lues in GRAF are used.
The call is:  CALL SURSZE (XMIN, XMAX, YMIN, YMAX) level 1, 2, 3
         or:  void sursze (float xmin, float xmax, float ymin, 
                                                    float ymax);
XMIN, XMAX    are user coordinates for the X-direction.
YMIN, YMAX    are user coordinates for the Y-direction.
Note:         For a logarithmic scaling,  the parameters must be
              exponents of base 10.
Name: GETMAT  23
The  routine  GETMAT calculates a  function matrix  for randomly
data points.                                                     
The call is:  CALL GETMAT (XRAY, YRAY, ZRAY, N, ZMAT, NX, NY, 
                           ZVAL, IMAT, WMAT)          level 2, 3
         or:  void getmat (float *xray, float *yray, 
                           float *zray, int n, float *zmat[],
                           int nx, int ny, int *imat[], 
                                                 float *wmat[]);  
XRAY, YRAY,   are  arrays  containing  the  randomly distributed
    ZRAY      data points.
N             is the number of points.
ZMAT          is the  function matrix  of the dimension (NX, NY)
              calculated by GETMAT.  The matrix elements corres-
              pond to a linear grid in the XY-plane whose limits
              are determined by the scaling values  in GRAF3D or
              SURSZE.
NX, NY        are the dimensions of ZMAT, IMAT and WMAT.
ZVAL          will be used  as a value  for matrix elements when
              no data points can be found in an area around  the
              corresponding grid points.  In general,  the start
              scaling of the Z-axis will be used for ZVAL.
IMAT          is a  working  matrix  of the dimension  (NX, NY).
              After  a call to  GETMAT,  IMAT(I, J) contains the
              number  of  random  data  points  found in an area
              around the grid points. The value -1  means that a
              random data value lies at a grid point.
WMAT          is a working matrix of the dimension (NX, NY).
Name: MDFMAT  23
The routine MDFMAT modifies the algorithm in GETMAT.
The call is:  CALL MDFMAT (IX, IY, W)              level 1, 2, 3
         or:  void mdfmat (int ix, int iy, float w);
IX, IY        are  the  number  of grid lines  in the X-  and Y-
              direction which determine the size  of the  region
              around data points.
W             is a weighting number.
                                           Default: (2, 2, 2.0).
Name: BOX3D   23
The routine BOX3D plots a border around the 3-D box.
The call is:  CALL BOX3D                                 level 3
         or:  void box3d (); 
Name: GRID3D  23
The routine GRID3D plots a grid in the 3-D box.
The call is:  CALL GRID3D (IGRID, JGRID, COPT)           level 3
         or:  void grid3d (int igrid, int jgrid, char *copt);
IGRID         is the number of grid lines between labels  in the
              X-direction (or Y-direction for the YZ-plane).
JGRID         is the number of grid lines between labels  in the
              Z-direction (or Y-direction for the XY-plane).
COPT          is a character string which defines where the grid
              will be plotted.
  = 'ALL'     will plot a grid in the XY-, XZ- and YZ-plane.
  = 'BACK'    will plot a grid in the XZ- and YZ-plane.
  = 'BOTTOM'  will plot a grid in the XY-plane.
Name: GRFINI  23
The routine GRFINI defines a plane in the 3-D box onto which all
plot vectors will be projected. The plane in the 3-D box corres-
ponds to a region in the  XY-plane which is determined by AXSPOS
and AXSLEN. GRFINI sets the level to 1.
The call is:  CALL GRFINI (X1, Y1, Z1, X2, Y2, Z2, X3, Y3, Z3)
                                                         level 3
         or:  void grfini (float x1, float x2, float x3,
                           float y1, float y2, float y3,
                           float z1, float z2, float z3);  
X1, Y1, Z1    are the absolute 3-D coordinates of the lower left
              corner of the 3-D plane.
X2, Y2, Z2    are  the  absolute  3-D  coordinates  of the lower
              right corner of the 3-D plane.
X3, Y3, Z3    are  the  absolute  3-D  coordinates  of the upper
              right corner of the 3-D plane.
Note:         If  (NXA,NYA)  is the lower  left corner,  NXL the
              width  and NYL the height of the region determined
              by  the  routines  AXSPOS  and  AXSLEN,  the point
              (X1,Y1,Z1)  corresponds to  (NXA,NYA),  (X2,Y2,Z2) 
              to  (NXA+NXL-1,NYA) and (X3,Y3,Z3) to  (NXA+NXL-1,
              NYA-NYL+1), respectively.
Name: GRFFIN  23
The routine GRFFIN terminates a  projection  into 3-D space. The
level will be set back to 3.
The call is:  CALL GRFFIN                          level 1, 2, 3
         or:  void grffin (); 
Name: STRT3D  23
The routine STRT3D moves the pen to a three-dimensional point.
The call is:  CALL STRT3D (X, Y, Z)                      level 3
         or:  void strt3d (float x, float y, float z);
X, Y, Z       are the absolute 3-D coordinates of the point.
Name: CONN3D  23
The routine CONN3D plots a line from the current pen position to
a three-dimensional point.  The line will be cut off at the sides
of the 3-D box. Different line styles can be used.
The call is:  CALL CONN3D (X, Y, Z)                      level 3
         or:  void conn3d (float x, float y, float z);
X, Y, Z       are the absolute 3-D coordinates of the point.
Name: VECTR3  23
The routine VECTR3 plots a vector in the 3-D box.
The call is:  CALL VECTR3 (X1, Y1 ,Z1, X2, Y2, Z2, IVEC) level 3
         or:  void vectr3 (float x1, float y1, float z1,
                        float x2, float y2, float z2, int ivec);
X1, Y1, Z1    are  the  absolute 3-D coordinates  of  the  start
              point.
X2, Y2, Z2    are the absolute 3-D coordinates of the end point.
IVEC          defines the arrow head (see VECTOR).
Name: POS3PT  23
The routine POS3PT converts three-dimensional  user  coordinates
to absolute 3-D coordinates.
The call is:  CALL POS3PT (X, Y, Z, XP, YP, ZP)          level 3
         or:  void pos3pt (float  x , float  y , float  z ,
                           float *xp, float *yp, float *zp);
X, Y, Z       are the user coordinates.
XP, YP, ZP    are  the  absolute  3-D  coordinates calculated by
POS3PT.
Name: X3DPOS  23
The function  X3DPOS  calculates from user coordinates  absolute
3-D X-coordinates.
The call is:  XP  =  X3DPOS (X, Y, Z)                    level 3
         or:  float  x3dpos (float x, float y, float z);
XP            is the absolute X-coordinate calculated by X3DPOS.
X, Y, Z       are the user coordinates.
Name: Y3DPOS  23
The function  Y3DPOS  calculates from user coordinates  absolute
3-D Y-coordinates.
The call is:  YP  =  Y3DPOS (X, Y, Z)                    level 3
         or:  float  y3dpos (float x, float y, float z);
YP            is the absolute Y-coordinate calculated by Y3DPOS.
X, Y, Z       are the user coordinates.
Name: Z3DPOS  23
The function  Z3DPOS  calculates  from user coordinates absolute
3-D Z-coordinates.
The call is:  ZP  =  Z3DPOS (X, Y, Z)                    level 3
         or:  float  z3dpos (float x, float y, float z);
ZP            is the absolute Z-coordinate calculated by Z3DPOS.
X, Y, Z       are the user coordinates.
Name: REL3PT  23
The routine  REL3PT  converts  user coordinates  to plot coordi-
nates.
The call is:  CALL REL3PT (X, Y, Z, XP, YP)              level 3
         or:  void rel3pt (float x, float  y , float z,
                                    float *xp, float *yp);
X, Y, Z       are the user coordinates.
XP, YP        are the plot coordinates calculated by REL3PT.
Name: X3DREL  23
The function  X3DREL  converts  user coordinates to plot coordi-
nates.
The call is:  XP =  X3DREL (X, Y, Z)                     level 3
         or:  float x3drel (float x, float  y , float z);
XP            is the plot coordinate calculated by X3DREL.
X, Y, Z       are the user coordinates.
Name: Y3DREL  23
The function  Y3DREL  converts user coordinates  to plot coordi-
nates.
The call is:  YP  = Y3DREL (X, Y, Z)                     level 3
         or:  float y3drel (float x, float  y , float z);
YP            is the plot coordinate calculated by Y3DREL.
X, Y, Z       are the user coordinates.
Name: ABS3PT  23
The routine  ABS3PT  converts  absolute 3-D coordinates  to plot
coordinates.
The call is:  CALL ABS3PT (X, Y, Z, XP, YP)              level 3
         or:  void abs3pt (float x, float  y , float z,
                                    float *xp, float *yp);
X, Y, Z       are the absolute 3-D coordinates.
XP, YP        are the plot coordinates calculated by ABS3PT.
Name: X3DABS  23
The function X3DABS  converts absolute  3-D coordinates  to plot
coordinates.
The call is:  XP  = X3DABS (X, Y, Z)                     level 3
         or:  float x3dabs (float x, float y, float z);
XP            is the plot coordinate calculated by X3DABS.
X, Y, Z       are the absolute 3-D coordinates.
Name: Y3DABS  23
The function Y3DABS  converts absolute  3-D coordinates to  plot
coordinates.
The call is:  YP  = Y3DABS (X, Y, Z)                     level 3
         or:  float y3dabs (float x, float y, float z);
YP            is the plot coordinate calculated by Y3DABS.
X, Y, Z       are the absolute 3-D coordinates.
