all functions - c

             c_adjust, c, mesh  
          or c_adjust, c, mesh, 1  
          or c= c_adjust(c, mesh, how)  
 
     adjust the cell number array C returned by track_reduce to  
     allow for a different layout of cell arrays than the one assumed  
     by the tracking routines.  Two HOW values are currently  
     supported: 0 (or nil) if the cell arrays are the same shape as  
     the nodal arrays, but the non-existent cell is at the end of  
     each row rather than at the beginning.  And 1 if the cell arrays  
     are smaller by one along each dimension than the nodal arrays.  
     If you call c_adjust as a subroutine, the input C array  
     is modified; if you call it as a function, the input C is  
     unchanged and the new values returned.  
interpreted function, defined at i0/hex.i   line 223  

             cage3  
          or cage3, onoff  
 
     Toggle the cage display.  If ONOFF is non-nil and non-zero,  
     turn on the cage.  If ONOFF is zero, turn off the cage.  
     The cage draws a rectangular box "behind" the 3D object and  
     attempts to put ticks and labels around the edge of the box.  
interpreted function, defined at i/pl3d.i   line 982  

             call, subroutine(arg1, arg2, arg3, arg4, arg5  
                              arg6, arg7, arg8);  
 
     allows a SUBROUTINE to be called with a very long argument list  
     as an alternative to:  
          subroutine, arg1, arg2, arg3, arg4, arg5,  
            arg6, arg7, arg8;  
     Note that the statement  
          subroutine(arg1, arg2, arg3, arg4, arg5,  
                     arg6, arg7, arg8);  
     will print the return value of subroutine, even if it is nil.  
     If invoked as a function, call simply returns its argument.  
interpreted function, defined at i0/std.i   line 2926  

             catch(category)  
 
     Catch errors of the specified category.  Category may be -1 to  
     catch all errors, or a bitwise or of the following bits:  
        0x01 math errors (SIGFPE, math library)  
        0x02 I/O errors  
        0x04 keyboard interrupts (e.g.- control C interrupt)  
        0x08 other compiled errors (YError)  
        0x10 interpreted errors (error)  
     Use catch by placing it in a function before the section of code  
     in which you are trying to catch errors.  When catch is called,  
     it always returns 0, but it records the virtual machine program  
     counter where it was called, and longjumps there if an error is  
     detected.  The most recent matching call to catch will catch the  
     error.  Returning from the function in which catch was called  
     pops that call off the list of catches the interpreter checks.  
     To use catch, place the call near the top of a function:  
        if (catch(category)) {  
          ......  
        }  
        ......  
     If an error with the specified category occurs in the "protected"  
     code, the program jumps back to the point of the catch and acts  
     as if the catch function had returned 1 (remember that when catch  
     is actually called it always returns 0).  
     In order to lessen the chances of infinite loops, the catch is  
     popped off the active list if it is actually used, so that a  
     second error will *not* be caught.  Often, this is only desirable  
     for the error handling code itself -- if you want to re-execute  
     the "protected" code, do this, and take care of the possibility  
     of infinite loops in your interpreted code:  
        while (catch(category)) {  
          ......  
        }  
        ......  
     After an error has been caught, the associated error message  
     (what would have been printed had it not been caught) is left  
     in the variable catch_message.  
builtin function, documented at i0/std.i   line 2681  

             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 1678  

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

             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  

 check_makefile  
 
  
interpreted function, defined at i/make.i   line 125  

               
 
     checks the length of files  
interpreted function, defined at contrib/gadget.i   line 880  

             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 1352  

             result= collect(f, name_string)  
 
     scans through all records of the history file F accumulating the  
     variable NAME_STRING into a single array with one additional  
     index varying from 1 to the number of records.  
     NAME_STRING can be either a simple variable name, or a name  
     followed by up to four simple indices which are either nil, an  
     integer, or an index range with constant limits.  (Note that  
     0 or negative indices count from the end of a dimension.)  
     Examples:  
        collect(f, "xle")        -- collects the variable f.xle  
        collect(f, "tr(2,2:)")   -- collects f.tr(2,2:)  
        collect(f, "akap(2,-1:0,)") -- collects f.akap(2,-1:0,)  
                     (i.e.- akap in the last two values of its  
                            second index)  
interpreted function, defined at i0/std.i   line 1847  

             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 1710  

 computeH  
 
  
interpreted function, defined at contrib/cosmo.i   line 97  

             conj(z)  
 
     returns the complex conjugate of its argument.  
builtin function, documented at i0/std.i   line 690  

             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 449  

             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 121  

             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  

 corr_func  
 
  
interpreted function, defined at contrib/randfield.i   line 455  

 cos  
 
builtin function, documented at i0/std.i   line 518  

 cosh  
 
builtin function, documented at i0/std.i   line 557  

             cosmo_param(Omega_m,Omega_lambda,Omega_k,q0)  
 
   Same as IDL routine:  
   Given any two of the four input parameters  
      (1) the normalized matter density Omega_m  
      (2) the normalized cosmolgical constant, Omega_lambda  
      (3) the normalized curvature term, Omega_k  
      (4) the deceleration parameter q0  
   this program will derive the remaining two.  
   Here "normalized" means divided by the closure density  
   so that Omega_m + Omega_lambda + Omega_k = 1. For a more  
   precise definition see Caroll, Press, & Turner (1992, ArAA, 30, 499).  
     
   If less than two parameters are defined, this procedure sets default   
   values of Omega_k=0 (flat space), Omega_lambda = 0.7, Omega_m = 0.3  
   and q0 = -0.5 in these order (by avoiding parameter defined) until  
   two parameters are defined.  
   If more than two parameters are defined upon input (overspecification),   
   then the first two defined parameters in the ordered list Omega_m,   
   Omega_lambda, Omega_k, q0 are used to define the cosmology.  
   INPUTS-OUTPUTS:  
      Omega_m     : Normalized matter energy density  
                    non-negative numeric scalar  
      Omega_lambda: Normalized cosmological constant  
                    numeric scalar  
      Omega_k     : Normalized curvature parmeter  
                    numeric scalar. This is  zero  
                    for a flat universe  
      q0          : Deceleration parameter  
                    numeric scalar  
                       = 0.5*Omega_m - Omega_lambda  
interpreted function, defined at contrib/cosmo.i   line 4  

              
 
   returns the normalized factorial moments  
   F_k= < N(N-1)..(N-k+1) >/< N(N-1)..(N-k+1) >_binomial  
   note that the first element corresponds to the void   
   EXAMPLE  
   uu=[];for(i=1;i<=1000;i++){xx=random(30);u=countincell1d(xx,L=1,nn=30,nl=25); grow,uu,[u];}  
   tt=count2moment(uu,er,k=4,error=1);  
   plb,tt(2:20,2:4)-1,marker=1,width=4;  
   plb,(tt+er/sqrt(1000))(2:20,2:4)-1,type=2  
   plb,(tt-er/sqrt(1000))(2:20,2:4)-1,type=3  
interpreted function, defined at contrib/countincell.i   line 119  

             2D countincell1d(xx,L)  
 
 EXAMPLE  
   uu=[];for(i=1;i<=35;i++){xx=random(80);u=countincell1d(xx,L=1,nn=30,nl=50); grow,uu,[u];}  
   plb,uu(,::5,avg),indgen(0:29),(1./indgen(50))(::5),width=4  
interpreted function, defined at contrib/countincell.i   line 1  

             2D countincell2d(xx,L)  
 
   EXAMPLE  
   uu=[];for(i=1;i<=15;i++){xx=random(8000,2);u=countincell2d(xx,L=1,nn=30,nl=50); grow,uu,[u];} pli,uu(,,avg)  
interpreted function, defined at contrib/countincell.i   line 25  

             3D countincell  
 
   EXAMPLE   uu=[];for(i=1;i<=15;i++){xx=random(8000,3);u=countincell3d(xx,L=1,nn=30,nl=50); grow,uu,[u];} pli,uu(,,avg)  
interpreted function, defined at contrib/countincell.i   line 48  

              
 
   returns covariance matrix of field u  
   (averaged over the second dim of u)  
   note that  
   res(indgen(n1)+n1*indgen(0:n1-1))-res(,rms)^2==0;  
     
interpreted function, defined at contrib/correl.i   line 50  

             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 2136  

             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 1343  

             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 2058  

             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 265  

 csch  
 
interpreted function, defined at i0/std.i   line 567  

             n= current_window()  
 
     returns the number of the current graphics window, or -1 if none.  
builtin function, documented at i0/graph.i   line 106