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: VFOC3D  23
The routine  VFOC3D  defines  the focus point.  It specifies the
location in the 3-D box that the camera points to.
The call is:  CALL VFOC3D (XFC, YFC, ZFC, CVU)     level 1, 2, 3
         or:  void vfoc3d (float xfc, float yfc, float zfc,
                                                      char *cvu)
XFC, YFC, ZFC define the position  of  the focus point.  If  CVU
              = 'ABS', the parameters must contain  absolute 3-D
              coordinates,  if CVU = 'USER',  they  must contain
              user coordinates.
CVU           is a character string defining the meaning of XFC,
              YFC and ZFC.
                                   Default: (0., 0., 0., 'ABS').
Name: VUP3D   23
The rotation  of the camera  around the  viewing axis is defined
by an angle.
The call is:  CALL VUP3D (ANG)                     level 1, 2, 3
         or:  void vup3d (float ang);
ANG           defines the rotation angle in degrees.  The camera
              is rotated in a clockwise direction.
                                               Default: ANG = 0.

Name: VANG3D  23
VANG3D  defines  the  view angle. It specifies the field of view
of the lens.
The call is:  CALL VANG3D (ANG)                    level 1, 2, 3
         or:  void vang3d (float ang);
ANG           defines the view angle in degrees.
                                              Default: ANG = 28.
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.
Notes:      - Colour values are calculated from the Z-scaling in
              the routine  GRAF3D or from the  parameters of the
              routine ZSCALE.
           -  A flat shading or a smooth shading can be selected
              with  the routine SHDMOD. The default is flat sha-
              ding. If smooth shading is selected, a Z-buffer is
              used for hidden-surface elimination. In this case,
              a raster format is needed for the graphics  output
              format      (for example METAFL ('XWIN') or METAFL
              ('TIFF')).
            - Additional grid lines can be enabled with the rou-
              tine SURMSH.
Name: SURFCP  23
A three-dimensional  parametric  function  is a function  of the
form   (x(t,u), y(t,u), z(t,u))  where   tmin <= t <= tmax   and
umin <= u <= umax.  The routine  SURFCP  plots a  shaded surface
from a parametric function.  The colours of the surface are cal-
culated  from the  Z-scaling  in the routine  GRAF3D or from the
parameters of the routine ZSCALE.
The call is:  CALL SURFCP (ZFUN, TMIN, TMAX, TSTEP, 
                                     UMIN, UMAX, USTEP)  level 3
         or:  void surfcp (float (*zfun)(), 
                           float tmin, float tmax, float tstep,
                           float umin, float umax, float ustep);
ZFUN          is the  name of a  FUNCTION  subroutine  with  the
              formal parameters X, Y and IOPT. If IOPT = 1, ZFUN
              should  return  the X-coordinate of the parametric
              function, if IOPT = 2, ZFUN should  return  the Y-
              coordinate and if IOPT = 3, ZFUN should return the
              Z-coordinate.
TMIN, TMAX,   define  the  range  and  step  size  of  the first
       TSTEP  parameter. 
UMIN, UMAX,   define the  range  and  step  size  of  the second
       USTEP  parameter.
Notes:     -  A flat shading or a smooth shading can be selected
              with  the routine SHDMOD. The default is flat sha-
              ding. If smooth shading is selected, a Z-buffer is
              used for hidden-surface elimination. In this case,
              a raster format is needed for the graphics  output
              format      (for example METAFL ('XWIN') or METAFL
              ('TIFF')).
            - Additional grid lines can be enabled with the rou-
              tine SURMSH.
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: SURMSH  23
The routine  SURMSH  can enable  additional  grid lines  for the
routines SURSHD and SURFCP.
The call is:  CALL SURMSH (COPT)                   level 1, 2, 3
         or:  void surmsh (char *copt);
COPT          is a character string  that  can  have  the values 
              'ON' and 'OFF'.
                                          Default: COPT = 'OFF'.
Name: CLIP3D  23
The routine CLIP3D defines 3-D clipping in the  world coordinate
system or in the eye coordinate system.
The call is:  CALL CLIP3D (COPT)                   level 1, 2, 3
         or:  void clip3d (char *copt);
COPT          is a character string  that  can  have  the values
              'WORLD' and 'EYE'.
                                        Default: COPT = 'WORLD'.
Name: VCLP3D  23
If 3-D clipping is done in the eye coordinate system,  front and
back clipping planes can be defined with the routine VCLP3D.
The call is:   CALL VCLP3D (XFRONT, XBACK)         level 1, 2, 3
         or:   void vlcp3d (float xfront, float xback);
XFRONT, XBACK  are  the distances from the viewpoint in absolute
               3-D coordinates. A negative value means infinity.
                                             Default: (1., -1.).
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: ZBFINI  23
The routine ZBFINI creates a Z-buffer.  The graphics output for-
mat must be set to a raster format  (for example METAFL ('XWIN')
or METAFL ('TIFF')).
The call is:  CALL ZBFINI (IRET)                     level 1,2,3
         or:  int  zbfini ();
IRET          is the returned status (0: no errors).
Name: ZBFFIN  23
The routine  ZBFFIN terminates writing  to a Z-buffer  and frees
the allocated space.
The call is:  CALL ZBFFIN                            level 1,2,3
         or:  void zbffin ();
Name: ZBFTRI  23
The routine  ZBFTRI plots a smooth triangle where hidden-surface
elimination is done with the Z-buffer.
The call is:  CALL ZBFTRI (XRAY, YRAY, ZRAY, IRAY)       level 3
         or:  void zbftri (float *xray, float *yray, 
                                        float *zray, int *iray);
XRAY, YRAY,   are the  X-, Y-,  and  Z-coordinates  of the three
       ZRAY   corners of the triangle in user coordinates.
IRAY          is an integer array  containing  the  three colour
              values of the triangle corners.          
Name: ZBFLIN  23
The routine ZBFLIN  plots a line in the current colour where the
Z-buffer  is used  for hiddenline elimination.  This routine  is 
used by SURSHD and SURFCP for drawing surface grids.
The call is:  CALL ZBFLIN (X1, Y1, Z1, X2, Y2, Z2)       level 3
         or:  void zbflin (float x1, float y1, float z1,
                           float x2, float y2, float z2);   
X1, Y1, Z1    are the user coordinates of the start point.
X2, Y2, Z2    are the user coordinates of the end point.
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.
