all functions - a

             abs(x)  
          or abs(x, y, z, ...)  
 
     returns the absolute value of its argument.  
     In the multi-argument form, returns sqrt(x^2+y^2+z^2+...).  
builtin function, documented at i0/std.i   line 674  

 accum  
 
  
interpreted function, defined at i/test1.i   line 225  

             alm= accumulate(n, f, mesh, rcap, rtrack, pts, dylm, flux, nrpp)  
 
     Do N batches (approximately rays_per_batch each, default 13000) of  
     rays from file F, MESH = hydra_mesh(F), analyzing the symmetry of  
     a capsule of radius RCAP (all rays tangent to this sphere),  
     tracing the rays only down to radius RTRACK (>1.001*RCAP).  
     This routine is designed to be called several times successively  
     to get better statistics.  PTS, DYLM, FLUX, and NRPP are all updated.  
     PTS = unit vectors in directions of points on capsule surface  
           defaults to bucky(3,1): 1280 points with an intrinsic  
           fidelity of about 1% out to l=12  
           use bucky(4,1,domega), dylm= get_ylm(pts,lmax,list)*domega(-,..)  
           to get 5120 points and intrinsic fidelity of about 0.2% at l=12  
     DYLM = ylm*domega for PTS  
     FLUX = accumulated flux at each of PTS; units are power/area  
     NRPP = accumulated number of rays per point of capsule surface  
     ALM = 91 coefficients of Ylm up to l=12 corresponding to FLUX  
           l= [0, 1,1, 2,2,2, 3,3,3,3, 4,4,4,4,4, ...]  
           m= [0, 0,1, 0,1,2, 0,1,2,3, 0,1,2,3,4, ...]  
interpreted function, defined at i/ylmdec.i   line 158  

             acos(x)  
 
     returns the inverse cosine of its argument, range [0, pi].  
builtin function, documented at i0/std.i   line 535  

 acosh  
 
interpreted function, defined at i0/std.i   line 580  

             coordinate transformation :  
 
   sexadecimal hour angle to decimal degree  
   for x(,1:3) and sexadecimal to decimal for x(,4:6)   
  see also : d2ad */  
interpreted function, defined at contrib/astools.i   line 3  

             add_member, file, struct_name, offset, name, type, dimlist  
 
     adds a member to a data type in the file FILE.  The data type name  
     (struct name) is STRUCT_NAME, which will be created if it does  
     not already exist.  The new member will be at OFFSET (in bytes)  
     from the beginning of an instance of this structure, and will  
     have the specified NAME, TYPE, and DIMLIST.  Use OFFSET -1 to  
     have add_member compute the next available offset in the structure.  
     The TYPE can be either a structure definition, or a string naming  
     a previously defined data type in FILE.  The optional DIMLIST is  
     as for the "array" function.  
     The STRUCT_NAME built from a series of add_member calls cannot be  
     used until it is installed with install_struct.  
     This function should be used very sparingly, mostly in code which  
     is building the structure of a foreign-format binary file.  
builtin function, documented at i0/std.i   line 2587  

             failure= add_next_file(file, filename, create_flag)  
 
     adds the next file to the FILE, which must contain history records.  
     If FILENAME is non-nil, the new file will be called that, otherwise  
     the next sequential filename is used.  If CREATE_FLAG is present  
     and non-zero, the new file will be created if it does not already  
     exist.  If omitted or nil, CREATE_FLAG defaults to 1 if the file has  
     write permission and 0 if it does not.  
     Returns 0 on success.  
builtin function, documented at i0/std.i   line 2654  

             add_record, file, time, ncyc  
          or add_record, file, time, ncyc, address  
          or add_record, file  
 
     adds a new record to FILE corresponding to the specified TIME and  
     NCYC (respectively a double and a long).  Either or both TIME  
     and NCYC may be nil or omitted, but the existence of TIME and  
     NCYC must be the same for every record added to one FILE.  
     If present, ADDRESS specifies the disk address of the new record,  
     which is assumed to be in the current file.  Without ADDRESS, or  
     if ADDRESS<0, the next available address is used; this may create  
     a new file in the family (see the set_filesize function).  
     The add_record function leaves the new record current  
     for subsequent save commands to actually write the data.  
     The TIME, NCYC, and ADDRESS arguments may be equal length vectors  
     to add several records at once; in this case, the first of the  
     newly added records is the current one.  If all three of TIME,  
     NCYC, and ADDRESS are nil or omitted, no new records are added,  
     but the file becomes a record file if it was not already, and in  
     any case, no record will be the current record after such an  
     add_record call.  
     After the first add_record call (even if no records were added),  
     subsequent add_variable commands will create record variables.  
     After the first record has been added, subsequent save commands  
     will create any new variables as record variables.  
     After a second record has been added using add_record, neither  
     save commands nor add_variable commands may be used to introduce  
     any new record variables.  
builtin function, documented at i0/std.i   line 2412  

             add_variable, file, address, name, type, dimlist  
 
     adds a variable NAME to FILE at the specified ADDRESS, with the  
     specified TYPE and dimensions given by DIMLIST.  The DIMLIST may  
     be zero or more arguments, as for the "array" function.  If the  
     ADDRESS is <0, the next available address is used. Note that,  
     unlike the save command, add_variable does not actually write any  
     data -- it merely changes Yorick's description of the contents of  
     FILE.  
     After the first add_record call, add_variable adds a variable to  
     the record instead of a non-record variable.  See add_record.  
builtin function, documented at i0/std.i   line 2446  

             adjust_ireg(ireg)  
 
     returns the input IREG with the regions specified in drat_ireg_adj  
     zeroed.  Beware-- the ireg array is actually modified.  
interpreted function, defined at i0/drat.i   line 427  

             aim3, xa,ya,za  
 
     move the current 3D plot to put the point (XA,YA,ZA) in object  
     coordinates at the point (0,0,0) -- the aim point -- in the  
     viewer's coordinates.  If any of XA, YA, or ZA is nil, it defaults  
     to zero.  
interpreted function, defined at i/pl3d.i   line 98  

 alloc_mesh  
 
  
interpreted function, defined at i0/drat.i   line 1015  

             allof(x)  
             anyof(x)  
             nallof(x)  
             noneof(x)  
 
     Respectively:  
      returns 1 if every element of the array x is non-zero, else 0.  
      returns 1 if at least one element of the array x is non-zero, else 0.  
      returns 1 if at least one element of the array x is zero, else 0.  
      returns 1 if every element of the array x is zero, else 0.  
builtin function, documented at i0/std.i   line 786  

            NT  
 
      almCl(alm)  
      returns the power spectrum deduced from alms.  
        
interpreted function, defined at contrib/harmonic.i   line 276  

            NT  
 
     field=almF(alm,nn)  
     returns the recomposed field  (dimensions nn*nn) using alm.  
     field is of the form theta along absiss phi along ordinate  
interpreted function, defined at contrib/harmonic.i   line 115  

            NT  
 
     field3D=almF3D(alm,nn)  
     returns the 3D recomposed field  (dimensions nn*nn*nn) using alm.  
     field is of the form theta along absiss phi along ordinate  
     r along alt ordinate  
     EXAMPLE  
     nn=10;  
     #include "Dom/Density_utils.i"  
     x=span(-1,1,nn)(,-:1:nn)(,,-:1:nn);  
     y=span(-1,1,nn)(-:1:nn,)(,,-:1:nn);  
     z=span(-1,1,nn)(-:1:nn,)(-:1:nn,,);  
     u=1/sqrt((x-1.1)^2+(y-1.1)^2+0.1^2);  
     v=Projec_Halo(u,[0.,0,0],[x,y,z],1.,sz=nn*2);  
     alm=Falm(v,nn);  
     u1=almF3D(alm,nn,xyz=1,rmax=1).re;  
     w=where(x^2+y^2+z^2<1);  
     pl,(u1 -u)(w)(*);  
     pl,(u1)(w)(*),color=-6;  
interpreted function, defined at contrib/harmonic.i   line 143  

 almT  
 
  
interpreted function, defined at contrib/harmonic.i   line 370  

 alm_cor  
 
  
interpreted function, defined at contrib/harmonic.i   line 304  

             alm_lmax(filename)  
 
     Get value of LMAX in A(l,m) file FILENAME (can be used to assert  
     validity of file).  
       
interpreted function, defined at contrib/healpix_io.i   line 12  

             alm_pack(a)  
 
       -or- alm_pack(a, lmax)  
     Returns packed A(l,m) data from array  A.  Input array A can be a real  
     2×(LMAX+1)×(LMAX+1) array or a complex (LMAX+1)×(LMAX+1) array or only  
     the lower  triangular part of A(l,m)  packed as a  complex vector with  
     NUMBER elements or a 2×NUMBER real  array.  If A is real, then A(1,..)  
     and  A(2,..) are  the real  and imaginary  parts of  the  A(l,m).  The  
     result is an array of float's with dimension 2×NUMBER such that:  
       RESULT(1, ) = real part of the A(l,m)  
       RESULT(2, ) = imaginary part of the A(l,m)  
     and with:  
       NUMBER = 1 + LMAX*(LMAX + 3)/2.  
     Optional argument  LMAX is  an output variable  to store the  value of  
     the parameter.  
       
interpreted function, defined at contrib/healpix_io.i   line 86  

 alm_rand  
 
  
interpreted function, defined at contrib/harmonic.i   line 330  

             alm_read(filename)  
 
     Read data  in A(l,m)  file FILENAME.  If  keyword UNPACK is  true, the  
     result  is a 2×(LMAX+1)×(LMAX+1)  array ortherwise  the result  is the  
     lower triangular part of A(l,m) packed as a 2×NUMBER array where:  
       NUMBER = 1 + LMAX*(LMAX + 3)/2  
     In any case, the result is such that:  
       RESULT(1,..)  = real part of the A(l,m)  
       RESULT(2,..)  = imaginary part of the A(l,m)  
       
interpreted function, defined at contrib/healpix_io.i   line 27  

            NT  
 
    field=almF(alm,nn)  
    returns the recomposed field  (dimensions nn*nn) using alm.  
     field is of the form theta along absiss phi along ordinate  
interpreted function, defined at contrib/harmonic.i   line 83  

 alm_tst  
 
  
interpreted function, defined at contrib/harmonic.i   line 401  

             alm_unpack(ap)  
 
     Unpack a 2×NUMBER array AP into a 2×(LMAX+1)×(LMAX+1) array  
     where:  
       NUMBER = 1 + LMAX*(LMAX + 3)/2  
     In any case, the result is such that:  
       RESULT(1,..)  = real part of the A(l,m)  
       RESULT(2,..)  = imaginary part of the A(l,m)  
       
interpreted function, defined at contrib/healpix_io.i   line 156  

              alm_write, filename, a;  
 
     Write A(l,m) data stored in array A into file FILENAME.  If keyword  
     OVERWRITE is true, FILENAME is overwritten if it already exists.  
     Input array A can be a real 2×(LMAX+1)×(LMAX+1) array or a complex  
     (LMAX+1)×(LMAX+1) array or only the lower triangular part of A(l,m)  
     packed as a complex vector with NUMBER elements or a 2×NUMBER real  
     array.  If A is real, then A(1,..) and A(2,..) are the real and  
     imaginary parts of the A(l,m).  
       
interpreted function, defined at contrib/healpix_io.i   line 53  

             alpha_primitives, file  
 
     sets FILE primitive data types to be native to DEC alpha workstations.  
interpreted function, defined at i0/std.i   line 2120  

             am_subroutine()  
 
     returns 1 if the current Yorick function was invoked as a subroutine,  
     else 0.  If am_subroutine() returns true, the result of the current  
     function will not be used, and need not be computed (the function  
     has been called for its side effects only).  
builtin function, documented at i0/std.i   line 508  

 analyse  
 
  
interpreted function, defined at contrib/yeti_hash_test.i   line 23  

             angdist(z,h0=,k=,lambda0=,Omega_m=,q0=,silent=)  
 
   Compute the Angular diameter distance (lumdist/(1+z)^2)  
       
interpreted function, defined at contrib/cosmo.i   line 263  

              angsize(dl,z,h0=,k=,lambda0=,Omega_m=,q0=,silent=)  
 
   Compute the apparent angular size of an object as a function of  
   redshift.  
   INPUTS:   dl - proper size of the object (in kpc)  
              z - redhsift values   
   EXAMPLE: plot the angular size of a 50 kpc diameter galaxy as  
            a function of redshift for the default cosmology  
            (Lambda = 0.7, Omega_m=0.3) up to z = 5  
              
        z = span(0.1,5,100)    //Angular size undefined at z = 0  
        pg,angsize(50,z),z;  
        xytitles,"z","Angular Size (\")"  
     
                
interpreted function, defined at contrib/cosmo.i   line 275  

             animate  
          or animate, 0/1  
 
     without any arguments, toggles animation mode; with argument 0,  
     turns off animation mode, with argument 1 turns on animation mode.  
     In animation mode, the X window associated with a graphics window  
     is actually an offscreen pixmap which is bit-blitted onscreen  
     when an fma command is issued.  This is confusing unless you are  
     actually trying to make a movie, but results in smoother animation  
     if you are.  Generally, you should turn animation on, run your movie,  
     then turn it off.  
builtin function, documented at i0/graph.i   line 322  

             any_in(left,x,right, mask, xx, a,aa, b,bb, c,cc  
 
    return the number of elements of the array X which are in the  
    interval LEFT < X <= RIGHT.  Also return MASK, which has the  
    shape of X and is 1 where X is in the interval and 0 otherwise,  
    and XX = X(where(MASK)).  Up to three optional arrays A, B, and C  
    of the same shape as X may be supplied; the arrays AA, BB, and CC  
    analogous to XX are returned.  LEFT or RIGHT may be [] for the  
    interval to extend to infinity on the corresponding side.  
    LEFT and/or RIGHT may be arrays as long as they are conformable  
    with X.  
interpreted function, defined at i/dawson.i   line 129  

 anyof  
 
builtin function, documented at i0/std.i   line 786  

             apply_funcs(streak_result)  
          or apply_funcs(transp, selfem)  
          or apply_funcs(transp, selfem, time)  
          or apply_funcs(transp, selfem, times)  
 
     applies the drat_backlight and drat_channel options (if any)  
     to the input streak_result.  This destroys the separate  
     transparency and self-emission information returned by streak.  
     transp= streak_result(,1,..) and selfem= streak_result(,2,..).  
     If time is not given, time=0.0 is passed to the functions.  
     If times is a vector, it must match the final dimension of  
     transp and selfem.  
interpreted function, defined at i0/drat.i   line 379  

 approx_eq  
 
  

 approx_eq  
 
  

             area(y, x)  
 
     returns the zonal areas of the 2-D mesh (X, Y).  If Y and X are  
     imax-by-jmax, the result is (imax-1)-by-(jmax-1).  The area is  
     positive when, say, X increases with i and Y increases with j.  
     For example, area([[0,0],[1,1]],[[0,1],[0,1]]) is +1.  
interpreted function, defined at i0/std.i   line 2835  

             array(value, dimension_list)  
          or array(type, dimension_list)  
 
     returns an object of the same type as VALUE, consisting of copies  
     of VALUE, with the given DIMENSION_LIST appended to the dimensions  
     of VALUE.  Hence, array(1.5, 3, 1) is the same as [[1.5, 1.5, 1.5]].  
     In the second form, the VALUE is taken as scalar zero of the TYPE.  
     Hence, array(short, 2, 3) is the same as [[0s,0s],[0s,0s],[0s,0s]].  
     A DIMENSION_LIST is a list of arguments, each of which may be  
     any of the following:  
        (1) A positive scalar integer expression,  
        (2) An index range with no step field (e.g.-  1:10), or  
        (3) A vector of integers [number of dims, length1, length2, ...]  
            (that is, the format returned by the dimsof function).  
builtin function, documented at i0/std.i   line 309  

             as_chars(x)  
             as_chars, x, xnew  
 
     return the bits of X as an array of char  
     return value has leading dimension of sizeof(x(1)), otherwise  
       same dimensions as X  
     in second form, sets bits of X to char array XNEW  
interpreted function, defined at i/ieee.i   line 53  

             asin(x)  
 
     returns the inverse sine of its argument, range [-pi/2, pi/2].  
builtin function, documented at i0/std.i   line 529  

             asinh(x)  
             acosh(x)  
             atanh(x)  
 
     returns the inverse hyperbolic sine, cosine, or tangent of  
     its argument.  The range of real acosh is >=0.0.  
interpreted function, defined at i0/std.i   line 580  

             atan(x)  
          or atan(y, x)  
 
     returns the inverse tangent of its argument, range [-pi/2, pi/2].  
     In the two argument form, returns the angle from (1, 0) to (x, y),  
     in the range (-pi, pi], with atan(1, 0)==pi/2.  (If x>=0, this is  
     the same as atan(y/x).)  
builtin function, documented at i0/std.i   line 541  

 atanh  
 
interpreted function, defined at i0/std.i   line 580  

             avg(x)  
 
     returns the scalar average of all elements of its array argument.  
builtin function, documented at i0/std.i   line 780