all functions - i

             i86_primitives, file  
 
     sets FILE primitive data types to be native to Linux i86 machines.  
interpreted function, defined at i0/std.i   line 2160  

             f = idl_open(filename)  
         or f = idl_open(filename, commons)  
 
    openb for an IDL save file  
    optional COMMONS is returned as an array of pointers to  
      arrays of strings; the first string in each array is the name  
      of an IDL common block; the others are the names of the  
      variables in that common block  
    all variable names have been converted to lower case  
    loud=1 keyword reports on timestamp and other information  
      about the user, host, etc., stored in the save file  
    
    floating complex data becomes an array of float with leading  
      dimension of 2, use f2z to recover complex  
    64 bit integers become an array of long with leading dimension  
      of 2, use l2ll to recover single long (if sizeof(long)=8)  
    
interpreted function, defined at i/idlsave.i   line 64  

             ieee_set, x, what  
 
     set X to ieee754 special value WHAT  
     X must be an array of float or double values  
       (note that X cannot be a scalar double value)  
     WHAT = 0  means leave unchanged  
     WHAT = 1  means set to Inf  
     WHAT = 2  means set to qNaN  
     WHAT = 3  means set to sNaN  
     WHAT = 4  means set to 0.0  
       negate WHAT to set the sign bit of X as well  
     WHAT may be an array conformable with X, in order to set only  
     some values of X  
     this routine is a no-op if this machine is not known to  
     support these ieee754 special values  
   Warning-- apparently there is no universal standard for what  
     constitutes signalling versus quiet NaN  
     on MIPS and HPPA architectures, qNaN and sNaN are reversed  
interpreted function, defined at i/ieee.i   line 408  

             ieee_test(x)  
 
     return values:  
     0 if this is an ordinary number  
     -1 if this is -Inf  
     1 if this is Inf  
     2 if this is qNaN  
     3 if this is sNaN  
     4 if this is a denormal  
     5 if this is a denormal which will be treated as NaN  
   Warning-- apparently there is no universal standard for what  
     constitutes signalling versus quiet NaN  
     on MIPS and HPPA architectures, qNaN and sNaN are reversed  
interpreted function, defined at i/ieee.i   line 326  

             ifd12(y)  
 
    return x = inverse of Fermi-Dirac integral of order 1/2,  
       y = integral[0 to inf]{ dt * t^0.5 / (exp(t-x)+1) }  
    accurate to about 1e-8  
interpreted function, defined at i/fermi.i   line 208  

             ifd32(y)  
 
    return x = inverse of Fermi-Dirac integral of order 3/2,  
       y = integral[0 to inf]{ dt * t^1.5 / (exp(t-x)+1) }  
    accurate to about 1e-8  
interpreted function, defined at i/fermi.i   line 239  

             ifd52(y)  
 
    return x = inverse of Fermi-Dirac integral of order 5/2,  
       y = integral[0 to inf]{ dt * t^2.5 / (exp(t-x)+1) }  
    accurate to about 1e-8  
interpreted function, defined at i/fermi.i   line 271  

             ifdm12(y)  
 
    return x = inverse of Fermi-Dirac integral of order -1/2,  
       y = integral[0 to inf]{ dt * t^-0.5 / (exp(t-x)+1) }  
    accurate to about 1e-8  
interpreted function, defined at i/fermi.i   line 173  

 ijakowski  
 
  
interpreted function, defined at i/demo4.i   line 85  

             im_part(z)  
 
     returns the imaginary part of its argument.  
     Unlike z.im, works if z is not complex (returns zero).  
interpreted function, defined at i0/std.i   line 702  

             #include "yorick_source.i"  
             require, filename  
             include, filename  
          or include, filename, now  
 
     #include is a parser directive, not a Yorick statement.  Use it  
     to read Yorick source code which you have saved in a file; the  
     file yorick_source.i will be read one line at a time, exactly as  
     if you had typed those lines at the keyboard.  The following  
     directories are searched (in this order) to find yorick_source.i:  
        .               (current working directory)  
        ~/yorick        (your personal directory of Yorick functions)  
        ~/Yorick        (your personal directory of Yorick functions)  
        Y_SITE/i        (Yorick distribution library)  
        Y_SITE/contrib  (contributed source at your site)  
     To find out what is available in the Y_SITE/i directory,  
     type:  
         library  
     You can also type  
         Y_SITE  
     to find the name of the site directory at your site, go to the  
     include or contrib subdirectory, and browse through the *.i files.  
     This is a good way to learn how to write a Yorick program.  Be  
     alert for files like README as well.  
     The require function checks to see whether FILENAME has already  
     been included (actually whether any file with the same final  
     path component has been included).  If so, require is a no-op,  
     otherwise, the action is the same as the include function with  
     NOW == 1.  
     The include function causes Yorick to parse and execute FILENAME  
     immediately.  The effect is similar to the #include parser  
     directive, except the finding, parsing, and execution of FILENAME  
     occurs at runtime.  If the NOW argument is given and positive,  
     the include occurs immediately, if nil or 0, it occurs just before  
     the next line would have been parsed.  If NOW is negative, the  
     include file is pushed onto a stack, and will be popped off and  
     parsed when all pending input has been processed.  
     Unless you are writing a startup file, or have some truly bizarre  
     technical reason for using the include function, use #include  
     instead.  The functional form of include may involve recursive  
     parsing, which you will not be able to understand without deep  
     study.  Stick with #include.  
builtin function, documented at i0/std.i   line 1614  

             indgen(n)  
          or indgen(start:stop)  
          or indgen(start:stop:step)  
 
     returns "index generator" list -- an array of longs running from  
     1 to N, inclusive.  In the second and third forms, the index  
     values specified by the index range are returned.  
builtin function, documented at i0/std.i   line 1023  

             info, expr  
 
     prints the data type and array dimensions of EXPR.  
interpreted function, defined at i0/std.i   line 157  

             install_struct, file, struct_name  
          or install_struct, file, struct_name, size, align, order  
          or install_struct, file, struct_name, size, align, order, layout  
 
     installs the data type named STRUCT_NAME in the binary FILE.  In  
     the two argument form, STRUCT_NAME must have been built by one or  
     more calls to the add_member function.  In the 5 and 6 argument calls,  
     STRUCT_NAME is a primitive data type -- an integer type for the 5  
     argument call, and a floating point type for the 6 argument call.  
     The 5 argument form may also be used to declare opaque data types.  
     SIZE is the size of an instance in bytes, ALIGN is its alignment  
     boundary (also in bytes), and ORDER is the byte order.  ORDER is  
     1 for most significant byte first, -1 for least significant byte  
     first, and 0 for opaque (unconverted) data.  Other ORDER values  
     represent more complex byte permutations (2 is the byte order for  
     VAX floating point numbers).  If ORDER equals SIZE, then the data  
     type is not only opaque, but also must be read sequentially.  
     LAYOUT is an array of 7 long values parameterizing the floating  
     point format, [sign_address, exponent_address, exponent_size,  
     mantissa_address, mantissa_size, mantissa_normalized, exponent_bias]  
     (the addresses and sizes are in bits, reduced to MSB first order).  
     Use, e.g., nameof(float) for STRUCT_NAME to redefine the meaning  
     of the float data type for FILE.  
builtin function, documented at i0/std.i   line 2605  

             integ(y, x, xp)  
          or integ(y, x, xp, which)  
 
     See the interp function for an explanation of the meanings of the  
     arguments.  The integ function returns ypi which is the integral  
     of the piecewise linear curve (X(i), Y(i)) (i=1, ..., numberof(X))  
     from X(1) to XP.  The curve (X, Y) is regarded as constant outside  
     the bounds of X.  Note that X must be monotonically increasing or  
builtin function, documented at i0/std.i   line 1118  

             integ_flat(opac, source, rays, mesh, slimits)  
          or integ_flat(opac, source, ray_paths)  
 
     returns ngroup-by-2-by-nrays result, where result(,1,..) is  
     the transparency factors, and result(,2,..) is the self-emission  
     for each group on each ray.  The input OPAC and SOURCE are the  
     opacity (an inverse length) and the source function (a specific  
     intensity).  They are mesh-by-ngroups zone centered arrays.  The  
     result has the same units as SOURCE.  
     In the second form, RAY_PATHS was returned by the track_rays  
     function.  
interpreted function, defined at i0/drat.i   line 1109  

             integ_linear(opac, source, rays, mesh, slimits)  
          or integ_linear(opac, source, ray_paths)  
 
     returns ngroup-by-2-by-nrays result, where result(,1,..) is  
     the transparency factors, and result(,2,..) is the self-emission  
     for each group on each ray.  The input OPAC and SOURCE are the  
     opacity (an inverse length) and the source function (a specific  
     intensity).  They are mesh-by-ngroups arrays; OPAC is zone centered,  
     while SOURCE is point centered (using pcen_source).  The result  
     has the same units as SOURCE.  
     In the second form, RAY_PATHS was returned by the track_rays  
     function.  
     The integ_linear routine assumes that the SOURCE function varies  
     linearly between the entry and exit points from each zone.  This  
     assumption is poor near the turning point, and causes the result  
     to be a discontinuous function of the ray coordinates, unlike the  
     integ_flat result.  
interpreted function, defined at i0/drat.i   line 1152  

             internal_rays(rays)  
 
     returns 6-element (cos,sin,y,z,x,r) representation of RAYS.  
     The first dimension of RAYS may be length 3, 5, or 6 to represent  
     the ray(s) in TDG/DIRT coordinates (x,y,theta), "best" coordinates  
     (x,y,z,theta,phi), or internal coordinates (cos,sin,y,z,x,r),  
     respectively.  The first dimension of the result always has length 6.  
     The internal coordinates are what Drat uses internally to  
     describe the ray.  The coordinate system is rotated about the  
     z-axis until the ray lies in a plane of constant y (there are at  
     least two ways to do this).  The point (x,y,z) can be any point on  
     the ray, and r=sqrt(x^2+y^2) is the corresponding cylindrical radius.  
     The clockwise angle theta from the +z-axis to the ray direction  
     (which always lies in the zx-plane) determines cos=cos(theta) and  
     sin=sin(theta).  
     As a specification of a ray, this system is triply redundant because  
     the point (x,y,z) could be any point on the ray, both the sine and  
     cosine of theta appear, and r=sqrt(x^2+y^2).  
     However, the slimits parameter -- used to specify the points along  
     a ray where the transport integration starts and stops -- is  
     measured from the point (x,y,z) specified as a part of the  
     (cos,sin,y,z,x,r) ray coordinate.  Thus, any change in the point  
     (x,y,z) on a ray must be accompanied by a corresponding change in  
     the slimits for that ray.  
interpreted function, defined at i/rays.i   line 155  

             interp(y, x, xp)  
          or interp(y, x, xp, which)  
 
     returns yp such that (XP, yp) lies on the piecewise linear curve  
     (X(i), Y(i)) (i=1, ..., numberof(X)).  Points beyond X(1) are set  
     to Y(1); points beyond X(0) are set to Y(0).  The array X must be  
     one dimensional, have numberof(X)>=2, and be either monotonically  
     increasing or monotonically decreasing.  The array Y may have more  
     than one dimension, but dimension WHICH must be the same length as  
     X.  WHICH defaults to 1, the first dimension of Y.  WHICH may be  
     non-positive to count dimensions from the end of Y; a WHICH of 0  
     means the final dimension of Y.  The result yp has dimsof(XP)  
     in place of the WHICH dimension of Y (if XP is scalar, the WHICH  
     dimension is not present).  (The dimensions of the result are the  
     same as if an index list with dimsof(XP) were placed in slot  
     WHICH of Y.)  
builtin function, documented at i0/std.i   line 1099  

             z0= interp2(y0,x0, z,y,x)  
 
       -or- z0= interp2(y0,x0, z,y,x,reg)  
     return the bilinear interpolate of the function Z(X,Y) at the  
     points (X0,Y0).  The X, Y, and optional REG arrays specify a  
     quadrilateral mesh as for the plm function.  The Z values are  
     specified at the vertices of this mesh, so Z must have the  
     same dimensions as X and Y.  
     Points outside the mesh get the value 0.0, unless the outside  
     keyword is non-nil, in which case they get that value.  
interpreted function, defined at i/digit2.i   line 36  

               
 
       
interpreted function, defined at contrib/correl.i   line 33  

 invgeom  
 
  
interpreted function, defined at i/test3.i   line 102  

 ipq_compute  
 
  
interpreted function, defined at i/random.i   line 361  

 ipq_function  
 
  
interpreted function, defined at i/random.i   line 449  

             model= ipq_setup(x, u)  
          or model= ipq_setup(x, u, power=[pleft,prght])  
          or model= ipq_setup(x, u, power=[pleft,prght], slope=[sleft,srght])  
 
     compute a model for the ipq_compute function, which computes the  
     inverse of a piecewise quadratic function.  This function occurs  
     when computing random numbers distributed according to a piecewise  
     linear function.  The piecewise linear function is u(x), determined  
     by the discrete points X and U input to ipq_setup.  None of the  
     values of U may be negative, and X must be strictly increasing,  
     X(i)0 while SRGHT<0.  If either power is greater than or equal to  
     100, an exponential tail will be used.  As a convenience, you may  
     also specify PLEFT or PRGHT of 0 to get an exponential tail.  
     Note: ipq_function(model, xp) returns the function values u(xp) at  
     the points xp, including the tails (if any).  ipq_compute(model, yp)  
     returns the xp for which (integral from -infinity to xp) of u(x)  
     equals yp; i.e.- the inverse of the piecewise quadratic.  
interpreted function, defined at i/random.i   line 276  

             is_array(object)  
 
     returns 1 if OBJECT is an array data type (as opposed to a function,  
     structure definition, index range, I/O stream, etc.), else 0.  
     An array OBJECT can be written to or read from a binary file;  
     non-array Yorick data types cannot.  
builtin function, documented at i0/std.i   line 460  

             is_func(object)  
 
     returns 1 if OBJECT is a Yorick interpreted function, 2 if OBJECT  
     is a built-in (that is, compiled) function, else 0.  
builtin function, documented at i0/std.i   line 469  

             is_present(get_vars(f), name)  
 
     returns 1 if variable NAME is present in file F, 0 if not.  
interpreted function, defined at i0/drat.i   line 889  

             is_prime(x)  
 
     return non-zero if and only if X (which must be a scalar integer)  
     is prime.  May return a false positive if X is greater than about  
     3e9, since at most 20000 candidate factors are checked.  
     The absolute value of X is taken first; zero is not prime, but 1 is.  
interpreted function, defined at i/gcd.i   line 64  

             is_range(object)  
 
     returns 1 if OBJECT is an index range (e.g.-  3:5 or 11:31:2),  
     else 0.  
builtin function, documented at i0/std.i   line 483  

 is_real  
 
  
interpreted function, defined at contrib/gadget.i   line 26  

             is_scalar(object)  
 
     returns 1 if OBJECT is a scalar, else 0.  
interpreted function, defined at i/string.i   line 223  

             is_stream(object)  
 
     returns 1 if OBJECT is a binary I/O stream (usually a file), else 0.  
     The _read and _write functions work on object if and only if  
     is_stream returns non-zero.  Note that is_stream returns 0 for a  
     text stream -- you need the typeof function to test for those.  
builtin function, documented at i0/std.i   line 497  

             is_struct(object)  
 
     returns 1 if OBJECT is the definition of a Yorick struct, else 0.  
     Thus, is_struct(double) returns 1, but is_struct(1.0) returns 0.  
builtin function, documented at i0/std.i   line 490  

             is_vector(object)  
 
     returns 1 if OBJECT is a vector (i.e., OBJECT has a single  
     dimension), else 0.  
interpreted function, defined at i/string.i   line 230  

             is_void(object)  
 
     returns 1 if OBJECT is nil (the one instance of the void data type),  
     else 0.  
builtin function, documented at i0/std.i   line 476  

 iterator3  
 
  
interpreted function, defined at i/slice3.i   line 520  

 iterator3_rect  
 
  
interpreted function, defined at i/slice3.i   line 529