section i of routines in global.i

all functions - i

i86_primitives


    i86_primitives, file  


sets FILE primitive data types to be native to Linux i86 machines.  
Interpreted function, defined at i0/std.i   line 2929

idl_open


    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

SEE ALSO: ieee_test, as_chars

ifd12


    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

SEE ALSO: ifdm12, ifd32, ifd52, fdm12, fd12, fd32, fd52

ifd32


    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

SEE ALSO: ifdm12, ifd12, ifd52, fdm12, fd12, fd32, fd52

ifd52


    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

SEE ALSO: ifdm12, ifd12, ifd32, fdm12, fd12, fd32, fd52

ifdm12


    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

SEE ALSO: ifd12, ifd32, ifd52, fdm12, fd12, fd32, fd52

ijakowski


    ijakowski  


  
     Interpreted function, defined at i/demo4.i   line 85

im_part


    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 749

include


    #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)  
   Y_SITE/i0       (Yorick startup and package include files)  
   Y_HOME/lib      (Yorick architecture dependent include files)  
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.  The NOW argument has the following meanings:  
  NOW == -1   filename pushed onto stack, popped and parsed  
              when all pending input is exhausted  
  NOW == 0    (or nil, default) parsed just before next input  
              line would be parsed  
  NOW == 1    parsed immediately, resuming current interpreted  
              program when finished (like require)  
  NOW == 2    like 0, except no error if filename does not exist  
  NOW == 3    like 1, except no error if filename does not exist  
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 2254

SEE ALSO: set_path, Y_SITE, plug_in, autoload, include_all

include_all


    include_all, dir1, dir2, ...  


include all files in directories DIR1, DIR2, ..., with names  
ending in the ".i" extension.  (This is mostly for use to load  
the i-start directories when yorick starts; see i0/stdx.i.)  
If any of the DIRi do not exist, or are empty, they are  
silently skipped.  Filenames beginning with "." are also skipped,  
even if they end in ".i".  The files are included in alphabetical  
order, DIR1 first, then DIR2, and so on.  
Interpreted function, defined at i0/std.i   line 2313

SEE ALSO: interp, digitize, span

integ_flat


    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 1111

SEE ALSO: integ_linear, track_rays, form_mesh, streak, snap

integ_linear


    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 1154

SEE ALSO: pcen_source, integ_flat, track_rays, form_mesh, streak, snap

internal_rays


    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

SEE ALSO: form_rays, best_rays, dirt_rays, get_s0, picture_rays

interp


    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 1178