cauer(np, ripple, atten, w)  
 or cauer(np, ripple, atten, w, wc, db)  


return frequency response (amplitude) for Cauer filter;  
the parameters are the same as for fil_cauer.  
Interpreted function, defined at i/filter.i   line 631  

    cd, directory_name  
 or cd(directory_name)  


change current working directory to DIRECTORY_NAME, returning  
the expanded path name (i.e.- with leading environment variables,  
., .., or ~ replaced by the actual pathname).  If called as a  
function, returns nil to indicate failure, otherwise failure  
causes a Yorick error.  
Builtin function, documented at i0/std.i   line 2453  

    ceil(x)  


returns the smallest integer not less than x (no-op on integers).  
Builtin function, documented at i0/std.i   line 709  

    cheby1(np, ripple, w)  
 or cheby1(np, ripple, w, wc, db)  


return frequency response (amplitude) for Chebyshev filter;  
the parameters are the same as for fil_cheby1.  
Interpreted function, defined at i/filter.i   line 580  

    cheby2(np, atten, w)  
 or cheby2(np, atten, w, wc, db)  


return frequency response (amplitude) for inverse Chebyshev filter;  
the parameters are the same as for fil_cheby2.  
Interpreted function, defined at i/filter.i   line 605  

    cheby_deriv(fit)  


  returns Chebyshev fit to the derivative of the function of the  
  input Chebyshev FIT.  
  
   Interpreted function, defined at i/cheby.i   line 76  

    cheby_eval(fit, x)  


  evaluates the Chebyshev fit (from cheby_fit) at points X.  
  the return values have the same dimensions as X.  
  
   Interpreted function, defined at i/cheby.i   line 36  

    fit = cheby_fit(f, interval, n)  
 or fit = cheby_fit(f, x, n)  


  returns the Chebyshev fit (for use in cheby_eval) of degree N  
  to the function F on the INTERVAL (a 2 element array [a,b]).  
  In the second form, F and X are arrays; the function to be  
  fit is the piecewise linear function of xp interp(f,x,xp), and  
  the interval of the fit is [min(x),max(x)].  
  
  The return value is the array [a,b, c0,c1,c2,...cN] where [a,b]  
  is the interval over which the fit applies, and the ci are the  
  Chebyshev coefficients.  It may be useful to use a relatively  
  large value of N in the call to cheby_fit, then to truncate the  
  resulting fit to fit(1:3+m) before calling cheby_eval.  
  
   Interpreted function, defined at i/cheby.i   line 7  

    cheby_integ(fit)  
 or cheby_integ(fit, x0)  


  returns Chebyshev fit to the integral of the function of the  
  input Chebyshev FIT.  If X0 is given, the returned integral will  
  be zero at X0 (which should be inside the fit interval fit(1:2)),  
  otherwise the integral will be zero at x=fit(1).  
  
   Interpreted function, defined at i/cheby.i   line 54  

    clear3  


Clear the current 3D display list.  
Interpreted function, defined at i/pl3d.i   line 714  

    close, f  


closes the I/O stream F (returned earlier by the open function).  
If F is a simple variable reference (as opposed to an expression),  
the close function will set F to nil.  If F is the only reference  
to the I/O stream, then "close, f" is equivalent to "f= []".  
Otherwise, "close, f" will close the file (so that subsequent  
I/O operations will fail) and print a warning message about the  
outstanding ("stale") references.  
Builtin function, documented at i0/std.i   line 1973  

    color_bar  
 or color_bar, levs, colors  


Draw a color bar below the current coordinate system.  If LEVS is  
not specified uses plfc_levs (set by previous call to plfc).  If  
COLORS is specified, it should have one more value than LEVS,  
otherwise equally spaced colors are chosen, or plfc_colors if  
plfc_levs was used.  With the vert=1 keyword the color bar appears  
to the left of the current coordinate system (vert=0 is default).  
By default, color_bar will attempt to label some of the color  
interfaces.  With the labs= keyword, you can force the labelling  
algorithm as follows: labs=0 supresses all labels, labs=n forces  
a label at every nth interface, labs=[i,n] forces a label at every  
nth interface starting from interface i (0<=i<=numberof(LEVS)).  
You can use the adjust= keyword to move the bar closer to (adjust<0)  
or further from (adjust>0) the viewport, and the height= keyword to  
set the height of any labels (default 14 points).  
Interpreted function, defined at i0/graph.i   line 1786  

    conj(z)  


returns the complex conjugate of its argument.  
Builtin function, documented at i0/std.i   line 737  

    nc= contour(yc,xc, level, z, y,x)  
 or nc= contour(yc,xc, level, z, y,x,ireg)  


  returns the points on the contour curve that would have been  
  plotted by plc.  Z, Y, X, and IREG are as for plc, and the  
  triangle= and region= keywords are accepted and have the same  
  meaning as for plc.  Unlike plc, the triangle array is an output  
  as well as an input to contour; if supplied it may be modified  
  to reflect any triangulations which were performed by contour.  
  LEVEL is a scalar z value to return the points at that contour  
  level.  All such points lie on edges of the mesh.  If a contour  
  curve closes, the final point is the same as the initial point  
  (i.e.- that point is included twice in the returned list).  
  LEVEL is a pair of z values [z0,z1] to return the points of  
  a set of polygons which outline the regions between the two  
  contour levels.  These will include points on the mesh boundary  
  which lie between the levels, in addition to the edge points  
  for both levels.  The polygons are closed, simply connected,  
  and will not contain more than about 4000 points (larger polygons  
  are split into pieces with a few points repeated where the pieces  
  join).  
  YC and XC are the output points on the curve(s), or nil if there  
  are no points.  On input, they must be simple variable references,  
  not expressions.  The return value NC is a list of the lengths of  
  the polygons/polylines returned in (XC,YC), or nil if there are  
  none.  numberof(XC)==numberof(YC)==sum(NC).  For the level pair  
  case, YC, XC, and NC are ready to be used as inputs to plfp.  
KEYWORDS: triangle, region  
  Builtin function, documented at i0/graph.i   line 505  

    conv3_rays(rays)  


convert [p,q] representation to or from best_rays representation.  
If the first dimension of RAYS is 3, returns 5-by-raydims array  
of best_rays; if first dimension of RAYS is 5, returns 3-by-raydims-  
by-2 [p,q] for use with hex5_track.  
Interpreted function, defined at i0/hex.i   line 123  

    convol(a,b)  


returns convolution of vector a with vector b, a vector  
of length na+nb-1 where na=numberof(a), nb=numberof(b).  
In detail, for i=[1 to na+nb-1]  
  result(i) = sum j=[max(1,1+i-nb) to min(na,i)] (a(j)*b(1+i-j))  
The n0= and n1= keywords can be used to control the section of  
the full array that is actually returned, 1<=n0 line 6  

    convol_check  


  
     Interpreted function, defined at i/convol.i   line 64  

    copyb, src, dst  
 or copyb, openb(src_name), createb(dst_name)  


Copy binary file SRC to binary file DST.  
Check for "obsolete/" subdirectory of Yorick home directory for  
extensions of the openb function to old file formats.  
Use the size= keyword to specify a non-default (4 Mbyte) size for  
the members of the output file family.  
If you habitually include basfix.i, you may want to use the  
basfix_openb function to open the src file.  
Interpreted function, defined at i/copyb.i   line 10  

    cos  


Builtin function, documented at i0/std.i   line 565  

    cosh  


Builtin function, documented at i0/std.i   line 604  

    cray_primitives, file  


sets FILE primitive data types to be native to Cray 1, XMP, and YMP.  
Interpreted function, defined at i0/std.i   line 2905  

    f= create(filename)  


is a synonym for       f= open(filename, "w")  
Creates a new text file FILENAME, destroying any existing file of  
that name.  Use the write function to write into the file F.  
Interpreted function, defined at i0/std.i   line 1964  

    file= createb(filename)  
 or file= createb(filename, primitives)  


creates FILENAME as a PDB file in "w+b" mode, destroying any  
existing file by that name.  If the PRIMITIVES argument is  
supplied, it must be the name of a procedure that sets the  
primitive data types for the file.  The default is to create  
a file with the native primitive types of the machine on which  
Yorick is running.  The following PRIMITIVES functions are  
predefined:  
   sun_primitives    -- appropriate for Sun, HP, IBM, and  
                        most other workstations  
   sun3_primitives   -- appropriate for old Sun-2 or Sun-3  
   dec_primitives    -- appropriate for DEC (MIPS) workstations, Windows  
   alpha_primitives  -- appropriate for DEC alpha workstations  
   sgi64_primitives  -- appropriate for 64 bit SGI workstations  
   cray_primitives   -- appropriate for Cray 1, XMP, and YMP  
   mac_primitives    -- appropriate for MacIntosh  
   macl_primitives   -- appropriate for MacIntosh, 12-byte double  
   i86_primitives    -- appropriate for Linux i86 machines  
   pc_primitives     -- appropriate for IBM PC  
   vax_primitives    -- appropriate for VAXen only (H doubles)  
   vaxg_primitives   -- appropriate for VAXen only (G doubles)  
   xdr_primitives    -- appropriate for XDR files  
Interpreted function, defined at i0/std.i   line 2827  

    nlist= cs_adjust(nlist, c, s, ireg)  


adjust NLIST, C, S returned from track_reduce to remove transits  
of cells for which IREG == 0.  Can be called before or after  
c_adjust, depending on layout of IREG.  
Interpreted function, defined at i0/hex.i   line 372  

    csch  


Interpreted function, defined at i0/std.i   line 614  

    n= current_window()  


returns the number of the current graphics window, or -1 if none.  
Builtin function, documented at i0/graph.i   line 106