all functions - r

             random(dimension_list)  
             random_seed, seed  
 
     returns an array of random double values with the given  
     DIMENSION_LIST (nil for a scalar result), uniformly distributed  
     on the interval from 0.0 to 1.0.  
     The algorithm is from Press and Teukolsky, Computers in Physics,  
     vol. 6, no. 5, Sep/Oct 1992 (ran2).  They offer a reward of $1000  
     to anyone who can exhibit a statistical test that this random  
     number generator fails in a "non-trivial" way.  
     The random_seed call reinitializes the random number sequence;  
     SEED should be between 0.0 and 1.0 non-inclusive; if SEED is  
     omitted, nil, or out of range, the sequence is reinitialized as  
     when Yorick starts.  
     The numbers are actually at the centers of 2147483562 equal width  
     bins on the interval [0,1].  Although only these 2 billion numbers  
     are possible, the period of the generator is roughly 2.3e18.  
builtin function, documented at i0/std.i   line 711  

             random_ipq(ipq_model, dimlist)  
 
     returns an array of double values with the given DIMLIST (see array  
     function, nil for a scalar result).  The numbers are distributed  
     according to a piecewise linear function (possibly with power law  
     or exponential tails) specified by the IPQ_MODEL.  The "IPQ" stands  
     for "inverse piecewise quadratic", which the type of function  
     required to transform a uniform random deviate into the piecewise  
     linear distribution.  Use the ipq_setup function to compute  
     IPQ_MODEL.  
interpreted function, defined at i/random.i   line 178  

             random_n(dimlist)  
 
     returns an array of normally distributed random double values with  
     the given DIMLIST (see array function, nil for a scalar result).  
     The mean is 0.0 and the standard deviation is 1.0.  
     The algorithm follows the Box-Muller method (see Numerical Recipes  
     by Press et al.).  
interpreted function, defined at i/random.i   line 129  

             random_rej(target_dist, ipq_model, dimlist)  
          or random_rej(target_dist, bounding_dist, bounding_rand, dimlist)  
 
     returns an array of double values with the given DIMLIST (see array  
     function, nil for a scalar result).  The numbers are distributed  
     according to the TARGET_DIST function:  
        func target_dist(x)  
     returning u(x)>=0 of same number and dimensionality as x, normalized  
     so that the integral of target_dist(x) from -infinity to +infinity  
     is 1.0.  The BOUNDING_DIST function must have the same calling  
     sequence as TARGET_DIST:  
        func bounding_dist(x)  
     returning b(x)>=u(x) everywhere.  Since u(x) is normalized, the  
     integral of b(x) must be >=1.0.  Finally, BOUNDING_RAND is a  
     function which converts an array of uniformly distributed random  
     numbers on (0,1) -- as returned by random -- into an array  
     distributed according to BOUNDING_DIST:  
        func bounding_rand(uniform_x_01)  
     Mathematically, BOUNDING_RAND is the inverse of the integral of  
     BOUNDING_DIST from -infinity to x, with its input scaled to (0,1).  
     If BOUNDING_DIST is not a function, then it must be an IPQ_MODEL  
     returned by the ipq_setup function.  In this case BOUNDING_RAND is  
     omitted -- ipq_compute will be used automatically.  
interpreted function, defined at i/random.i   line 198  

 random_seed  
 
builtin function, documented at i0/std.i   line 711  

             random_u(a, b, dimlist)  
 
     return uniformly distributed random numbers between A and B.  
     (Will never exactly equal A or B.)  The DIMLIST is as for the  
     array function.  Same as (b-a)*random(dimlist)+a.  If A==0,  
     you are better off just writing B*random(dimlist).  
interpreted function, defined at i/random.i   line 112  

             random_x(dimlist)  
 
     same as random(DIMLIST), except that random_x calls random  
     twice at each point, to avoid the defect that random only  
     can produce about 2.e9 numbers on the interval (0.,1.) (see  
     random for an explanation of these bins).  
     You may set random=random_x to get these "better" random  
     numbers in every call to random.  
     Unlike random, there is a chance in 1.e15 or so that random_x  
     may return exactly 1.0 or 0.0 (the latter may not be possible  
     with IEEE standard arithmetic, while the former apparently is).  
     Since cosmic rays are far more likely, you may as well not  
     worry about this.  Also, because of rounding errors, some bit  
     patterns may still be more likely than others, but the 0.5e-9  
     wide bins of random will be absent.  
interpreted function, defined at i/random.i   line 73  

             randomize  
             randomize()  
 
     set the seed for random "randomly" (based on the timer clock  
     and the current state of random).  As a function, returns the  
     value of the seed passed to random_seed.  
interpreted function, defined at i0/std.i   line 733  

             range, ymin, ymax  
 
     sets the y-axis plot limits in the current coordinate system to  
     YMIN, YMAX, which may be nil or omitted to leave the corresponding  
     limit unchanged, a number to fix the corresponding limit to a  
     specified value, or the string "e" to make the corresponding limit  
     take on the extreme value of the currently displayed data.  
     Use    limits, xmin, xmin  
     to accomplish the same function for the x-axis plot limits.  
interpreted function, defined at i0/graph.i   line 773  

             range3, zmin,zmax  
 
     Set the 3D axis z limits for use with the cage.  
     Use keyword aspect=[ax,ay,az] to set the aspect ratios of the  
     cage to ax:ay:az -- that is, the ratios of the lengths of the  
     cage axes will become ax:ay:az.  
interpreted function, defined at i/pl3d.i   line 221  

 raw_not_cdf  
 
  
interpreted function, defined at i/netcdf.i   line 57  

             raw_style: get_style, set_style, read_style, write_style  
             #include "style.i"  
 
     alternatives to the style= keyword of the window command which  
     allow the interpreter to set or get all the details of the  
     window style.  Include "style.i" and read the help for get_style.  
builtin function, documented at i0/graph.i   line 1439  

             rdline(f)  
          or rdline(f, n, prompt= pstring)  
 
     returns next line from stream F (stdin if F nil).  If N is non-nil,  
     returns a string array containing the next N lines of F.  If  
     end-of-file occurs, rdline returns nil strings.  If F is nil,  
     uses the PSTRING to prompt for input (default "read> ").  
builtin function, documented at i0/std.i   line 1479  

             n= read(f, format=fstring, obj1, obj2, ...)  
          or n= read(prompt= pstring, format=fstring, obj1, obj2, ...)  
          or n= sread(source, format=fstring, obj1, obj2, ...)  
 
     reads text from I/O stream F (1st form), or from the keyboard (2nd  
     form), or from the string or string array SOURCE (3rd form),  
     interprets it according to the optional FSTRING, and uses that  
     interpretation to assign values to OBJ1, OBJ2, ...  If the input  
     is taken from the keyboard, the optional prompt PSTRING (default  
     "read> ") is printed before each line is read.  The Yorick write  
     function does not interact with the read function -- writes are  
     always to end-of-file, and do not affect the sequence of lines  
     returned by read.  The backup (and bookmark) function is the  
     only way to change the sequence of lines returned by read.  
     There must be one non-supressed conversion specifier (see below)  
     in FSTRING for each OBJ to be read; the type of the conversion  
     specifier must generally match the type of the OBJ.  That is,  
     an integer OBJ requires an integer specifier (d, i, o, u, or x)  
     in FSTRING, a real OBJ requires a real specifier (e, f, or g),  
     and a string OBJ requires a string specifier (s or []).  An OBJ  
     may not be complex, a pointer, a structure instance, or any non-  
     array Yorick object.  If FSTRING is not supplied, or if it has  
     fewer conversion specifiers than the number of OBJ arguments,  
     then Yorick supplies default specifiers ("%ld" for integers,  
     "%lg" for reals, and "%s" for strings).  If FSTRING contains more  
     specifiers than there are OBJ arguments, the part of FSTRING  
     beginning with the first specifier with no OBJ is ignored.  
     The OBJ may be scalar or arrays, but the dimensions of every OBJ  
     must be identical.  If the OBJ are arrays, Yorick behaves as  
     if the read were called in a loop numberof(OBJ1) times, filling  
     one array element of each of the OBJ according to FSTRING on  
     each pass through the loop.  (Note that this behavior includes  
     the case of reading columns of numbers by a single call to read.)  
     The return value N is the total number of scalar assignments  
     which were made as a result of this call.  (If there were 4  
     OBJ arguments, and each was an array with 17 elements, a return  
     value of N==35 would mean the following:  The first 8 elements  
     of OBJ1, OBJ2, OBJ3, and OBJ4 were read, and the 9th element of  
     OBJ1, OBJ2, and OBJ3 was read.)  The read function sets any  
     elements of the OBJ which were not read to zero -- hence,  
     independent of the returned N, the all of the old data in the  
     OBJ arguments is overwritten.  
     The read or sread functions continue reading until either:  
     (1) all elements of all OBJ have been filled, or (2) end-of-file  
     (or end of SOURCE for sread) is reached ("input failure"), or  
     (3) part of FSTRING or a conversion specifier supplied by  
     default fails to match the source text ("matching failure").  
     The FSTRING is composed of a series of "directives" which are  
     (1) whitespace -- means to skip any amount of whitespace in the  
         source text  
     (2) characters other than whitespace and % -- must match the  
         characters in the source text exactly, or matching failure  
         occurs and the read operation stops  
     (3) conversion specifiers beginning with % and ending with a  
         character specifying the type of conversion -- optionally  
         skip whitespace, then convert as many characters as  
         continue to "look like" the conversion type, possibly  
         producing a matching failure  
     The conversion specifier is of the form %*WSC, where:  
  is either the character '*' or not present  
       A specifier beginning with %* does not correspond to any of  
       the OBJ; the converted value will be discarded.  
     W is either a positive decimal integer specifying the maximum  
       field width (not including any skipped leading whitespace),  
       or not present if any number of characters up to end-of-line  
       is acceptable.  
     S is either one of the characters 'h', 'l', or 'L', or not  
       present.  Yorick allows this for compatibility with the C  
       library functions, but ignores it.  
     C is a character specifying the type of conversion:  
       d   - decimal integer  
       i   - decimal, octal (leading 0), or hex (leading 0x) integer  
       o   - octal integer  
       u   - unsigned decimal integer (same as d for Yorick)  
       x, X            - hex integer  
       e, f, g, E, G   - floating point real  
       s   - string of non-whitespace characters  
       [xxx]   - (xxx is any sequence of characters) longest string  
                 of characters matching those in the list  
       [^xxx]  - longest string of characters NOT matching those in  
                 the list (this is how you can extend %s to be  
                 delimited by something other than whitespace)  
       %   - the ordinary % character; complete conversion  
             specification must be "%%"  
     The read function is modeled on the ANSI standard C library  
     fscanf and sscanf functions, but differs in several respects:  
       (1) Yorick's read cannot handle the %c, %p, or %n conversion  
           specifiers in FSTRING.  
       (2) Yorick's read never results in a portion of a line  
           being read -- any unused part of a line is simply discarded  
           (end FSTRING with "%[^\n]" if you want to save the trailing  
           part of an input line).  
       (3) As a side effect of (2), there are some differences between  
           fscanf and Yorick's read in how whitespace extending across  
           newlines is handled.  
builtin function, documented at i0/std.i   line 1373  

 readSnapTimings  
 
  
interpreted function, defined at contrib/gadget.i   line 902  

              reads gadget Timing file   
 
   EXEMPLE  plg,readTimings("~/gadget/test/timings.txt")(dif);  
interpreted function, defined at contrib/gadget.i   line 911  

             file= read_clog(file, clog_name)  
 
     raw routine to set the binary data structure of FILE according  
     to the text description in the Contents Log file CLOG_NAME.  
builtin function, documented at i0/std.i   line 1880  

 read_flat  
 
  
interpreted function, defined at i/testb.i   line 487  

               
 
     read_halo_tree(fname) reads a   
     anahop file and returns a CHalo structure.  
     EXAMPLE  
     h1=read_halo_tree("seed064853998_128_012_000.nodes");  
     ws1; PL,h1.density,h1.mass;  
interpreted function, defined at contrib/gadget.i   line 101  

 read_hist  
 
  
interpreted function, defined at i/testb.i   line 328  

             read_n, f, n0, n1, n2, ...  
 
     grabs the next numbers N0, N1, N2, ... from file F, skipping over  
     any whitespace, comma, semicolon, or colon delimited tokens which  
     are not numbers.  (Actually, only the first and last characters of  
     the token have to look like a number -- 4xxx3 would be read as 4.)  
     ***WARNING*** at most ten Ns are allowed  
     The Ns can be arrays, provided all have the same dimensions.  
interpreted function, defined at i0/std.i   line 1489  

 read_otable  
 
  
interpreted function, defined at i/ylmdec.i   line 369  

 read_ptrs  
 
  
interpreted function, defined at i/testb.i   line 612  

 read_state  
 
  
interpreted function, defined at i/ylmdec.i   line 259  

             read_style, file, landscape, systems, legends, clegends  
 
     read a Gist style sheet (.gs file), and return the data  
     structures as described in the get_style function.  The FILE  
     can be a filename or a text file stream.  
interpreted function, defined at i/style.i   line 312  

             recenter cube on coordinates coor  
 
   EXAMPLE  
   x=span(0,1,15)(,-:1:16)(,,-:1:17);  
   y=span(0,1,16)(-:1:15,)(,,-:1:17);  
   z=span(0,1,17)(-:1:16,)(-:1:15,,);  
   u=abs(x-0.5,y-0.5,z-0.5);  
   v=recenter(u,[3,4,5]);  
   need not be a cube; can be a rectangle or a hypercube  
interpreted function, defined at contrib/split.i   line 604  

             recover_file, filename  
          or recover_file, filename, clogfile  
 
     writes the descriptive information at the end of a corrupted  
     binary file FILENAME from its Contents Log file CLOGFILE, which  
     is FILENAME+"L" by default.  
interpreted function, defined at i0/std.i   line 1886  

             redraw  
 
     redraws the X window associated with the current graphics window.  
builtin function, documented at i0/graph.i   line 278  

 redshiftDist  
 
  
interpreted function, defined at contrib/correl.i   line 83  

             reform(x, dimlist)  
 
     returns array X reshaped according to dimension list DIMLIST.  
     In most cases, prefer this to reshape.  
interpreted function, defined at i/string.i   line 197  

             c= reg_track(x, y, z, rays, s)  
 
     track RAYS through regular mesh defined by the 1D coordinate  
     arrays X, Y, and Z.  Return values S and C are as for  
     hex5_track, where the mesh is numberof(X) by numberof(Y) by  
     numberof(Z).  
builtin function, documented at i0/hex.i   line 83  

 remove  
 
builtin function, documented at i0/std.i   line 1365  

             rename, old_filename, new_filename  
             remove filename  
 
     rename or remove a file.  
builtin function, documented at i0/std.i   line 1365  

 require  
 
builtin function, documented at i0/std.i   line 1614  

 reset  
 
  
interpreted function, defined at i/demo1.i   line 37  

             reset_options  
 
     resets all options for the streak, snap, and streak_save functions  
     to their default values.  
interpreted function, defined at i0/drat.i   line 854  

             reshape, reference, address, type, dimension_list  
          or reshape, reference, type, dimension_list  
          or reshape, reference  
 
     The REFERENCE must be an unadorned variable, not an expression;  
     reshape sets this variable to an LValue at the specified ADDRESS  
     with the specified TYPE and DIMENSION_LIST.  (See the array  
     function documentation for acceptable DIMENSION_LIST formats.)  
     If ADDRESS is an integer (e.g.- a long), the programmer is  
     responsible for assuring that the data at ADDRESS is valid.  
     If ADDRESS is a (Yorick) pointer, Yorick will assure that the  
     data pointed to will not be discarded, and the reshape will  
     fail if TYPE and DIMENSION_LIST extend beyond the pointee  
     bounds.  In the second form, ADDRESS is taken to be &REFERENCE;  
     that is, the TYPE and DIMENSION_LIST of the variable are changed  
     without doing any type conversion.  In the third form, REFERENCE  
     is set to nil ([]).  (Simple redefinition will not work on a  
     variable defined using reshape.)  
     WARNING: There are almost no situations for which reshape is  
       the correct operation.  See reform in Y_SITE/i/string.i.  
builtin function, documented at i0/std.i   line 264  

 restore  
 
builtin function, documented at i0/std.i   line 2311  

             restore3, view  
 
     Restore a previously saved 3D viewing transformation and lighting.  
     If VIEW is nil, rotate object to viewer's coordinate system.  
interpreted function, defined at i/pl3d.i   line 242  

             rez_adjust_mesh  
 
     is an optional hook function which is called after any change to the  
     mesh (e.g.- by dragging points) has been made.  If it is defined, it  
     may modify the external variables rez_rt and rez_zt.  This hook can  
     be used, for example, to force points along some k or l line to lie  
     along a symmetry line.  
builtin function, documented at i/rezone.i   line 130  

             rez_all  
 
     Click on [Drag Points] to drag points around with the mouse with  
     rez_drag.  
     Click on [Adjust Line] to adjust points along a line segment with  
     rez_ladj.  
     Click on [Adjust Region] to adjust points in a rectangular region  
     with rez_radj.  
     Click on the [Undo] button to undo the previous change.  
     Click on the [Redo] button to redo the previous undo.  
     Click on the [Revert] to return to the original mesh.  
     When you are finished moving points around, click on [OK].  
     Click on [Escape] to exit with a non-zero return value.  
     Click on [Zoom or Pan] to change the plot limits (see rez_zoom).  
     Click on [Set Styles] to change the line styles or colors (see  
     rez_style).  
interpreted function, defined at i/rezone.i   line 423  

 rez_chk_palette  
 
  
interpreted function, defined at i/rezone.i   line 98  

 rez_color  
 
builtin function, documented at i/rezone.i   line 39  

 rez_ding  
 
  
interpreted function, defined at i/rezone.i   line 1517  

             rez_drag  
 
     Allow points in the rezone mesh to be dragged around with  
     the mouse.  Press mouse button near a vertex, move mouse  
     to desired position of that vertex, and release button.  
     If the point where you click is less than twice the distance to the  
     second closest point than to the nearest point, the point will not  
     be moved (you will hear a beep when you release the button).  
     Click on the [Undo] button to undo the previous move; you can undo  
     up to 100 previous moves by successive [Undo] clicks.  
     When you are finished moving points around, click on [OK].  
     Click on [Zoom or Pan] to change the plot limits (see rez_zoom).  
     Click on [Set Styles] to change the line styles or colors (see  
     rez_style).  
interpreted function, defined at i/rezone.i   line 532  

 rez_find  
 
  
interpreted function, defined at i/rezone.i   line 1493  

 rez_getrz  
 
  
interpreted function, defined at i/rezone.i   line 1451  

 rez_getvar  
 
  
interpreted function, defined at i/rezone.i   line 1506  

             rez_kstyle, rez_lstyle, rez_color  
 
     is a vector of three longs:  [type,width,color]  
     type MUST be 1, 2, 3, 4, or 5,  
     width MUST be 1, 2, 3, 4, 5, 6, 7, or 8,  
     and color MUST be -1, -2, -3, -4, -5, -6, -7, -8, -9, or -10  
     Either or both parameters may be set before or after including  
     rez.i; by default:  
       rez_kstyle= [4, 1, -2]    (dashdot, thin, foreground color)  
       rez_lstyle= [1, 1, -2]    (solid, thin, foreground color)  
     To distinguish K and L by color instead of type, try:  
       rez_kstyle= [1, 1, -7]    (dashdot, thin, blue)  
       rez_lstyle= [1, 1, -5]    (solid, thin, red)  
     If the variable rez_color is true (non-nil and non-zero) when  
     this file is included, then these will be the default.  
builtin function, documented at i/rezone.i   line 39  

             rez_ladj  
 
     Adjust the points along a logical line segment PQ:  
     Click on [Set P] or [Set Q] to set the endpoints of the segment.  
     When P and Q have been set, click [OK]; this button will  
     read [Cancel] if P and Q do not have either the same K or the  
     same L index.  
     Click on [Smooth] to smooth the points along PQ.  
     Click on [Equal Space] to make the points along PQ equally spaced.  
     This forces PQ to be a straight line.  
     Drag any point between P and Q to get equal ratio spacing of all  
     the points between P and Q.  This also forces PQ to be a straight  
     line; if PQ is initially curved, you may want to click on  
     [Equal Space] before you attempt to drag points.  
     Click on the [Undo] button to undo the previous adjustment; you can  
     undo up to 20 previous adjustments by successive [Undo] clicks.  
     When you are finished adjusting lines, click on [OK].  
     Click on [Zoom or Pan] to change the plot limits (see rez_zoom).  
     Click on [Set Styles] to change the line styles or colors (see  
     rez_style).  
     Hint:  
         You can select a center point as the second point during  
         rez_ladj.  When you do this, the K (or L) value of this second  
         point will be the same as that of the first point --  
         otherwise there is no way to distinguish among all of the  
         logical points at the center.  
interpreted function, defined at i/rezone.i   line 615  

             rez_load_hook  
 
     If non-nil, filename to be included immediately after rez.i.  
     This file can be used to set personalized default values for the  
     many parameters.  
     Some parameters may be set before loading rez.i, as well  
builtin function, documented at i/rezone.i   line 30  

 rez_lstyle  
 
builtin function, documented at i/rezone.i   line 39  

             rez_mark  
 
     Causes rezone functions to mark bowtied or chevroned (boomeranged)  
     zones when the mesh is plotted.  MUST have one of the following values:  
       0 to not mark bowtied or chevroned zones  
       1 to put a B at the center of the positive triangle of bowtied zones  
       2 to put a C at the center of the larger wing of chevroned zones  
       3 to mark both bowtied and chevroned zones  
     By default, rez_mark is 3; you may set it to a different value  
     either before or after including rez.i.  
builtin function, documented at i/rezone.i   line 66  

             rez_mesh, rt, zt, ireg  
 
       -or- rez_mesh, rt, zt  
       -or- rez_mesh, zfile  
     set mesh for rez_... commands.  If ZFILE is specified, it must be a  
     binary file containing variables RT, ZT, and (optionally) IREG.  
interpreted function, defined at i/rezone.i   line 1373  

             rez_next  
 
     zoom in on next bowtied (or chevroned) zone (after rez_mesh).  
     With numeric argument, zooms to that bowtie (or chevron).  With  
     numeric argument 0, zooms to current bowtie (or chevron).  
interpreted function, defined at i/rezone.i   line 1410  

             rez_palette  
 
     3-by-ncolors array used as a palette when rez_regs region coloring  
     is set.  The index in rez_regs is the second index into rez_palette.  
     The length 3 first index is [r,g,b].  
     The default is 15 pastels.  
builtin function, documented at i/rezone.i   line 84  

 rez_plm  
 
  
interpreted function, defined at i/rezone.i   line 140  

             rez_prev  
 
     zoom in on previous bowtied (or chevroned) zone (after rez_mesh).  
interpreted function, defined at i/rezone.i   line 1442  

 rez_ptexist  
 
  
interpreted function, defined at i/rezone.i   line 1474  

             rez_qrt, rez_qzt, rez_qireg  
 
     are the names of the mesh variables for rez_mesh, "rt", "zt", and  
     "ireg" by default.  Note that ireg is optional.  
builtin function, documented at i/rezone.i   line 1364  

             rez_radj  
 
     Adjust the points in a logical rectangle PQRS:  
     Click on [Set P] or [Set R] to set the endpoints of the segment.  
     When P and R have been set, click [OK]; this button will  
     read [Cancel] if P and R have the same K or the same L index.  
     Click on a point on any edge of PQRS (but not one of the corners)  
     to copy the spacings on that edge throughout the entire region.  
     All of the lines of the same type (K-line or L-line) as the edge  
     you clicked on will become straight lines.  
     Click on [Smooth] to smooth the points interior to PQRS.  
     Click on [Smooth 4] to perform the smooth operation four times.  
     Click on the [Undo] button to undo the previous adjustment; you can  
     undo up to 10 previous adjustments by successive [Undo] clicks.  
     When you are finished adjusting regions, click on [OK].  
     Click on [Zoom or Pan] to change the plot limits (see rez_zoom).  
     Click on [Set Styles] to change the line styles or colors (see  
     rez_style).  
     Hint:  
         You can select a center point as the second point during  
         rez_radj.  When you do this, the K (or L) value of this second  
         point will be the same as that of the first point --  
         otherwise there is no way to distinguish among all of the  
         logical points at the center.  The center point will be labeled  
         Q instead of R as usual, and you will need to choose a third  
         point (S) to complete the rectangle PQRS.  
interpreted function, defined at i/rezone.i   line 865  

 rez_range  
 
  
interpreted function, defined at i/rezone.i   line 1515  

             rez_regs  
 
     is a vector of region numbers which are to be drawn in the colors  
     specified in rez_palette.  Thus:  
        rez_regs= [3,5]  
     causes regions 3 and 5 to be drawn in colors.  All other regions have  
     white backgrounds.  Hilighting too many regions in this way may slow  
     down the redraws unacceptably.  To highlight all regions, use:  
        rez_regs= indgen(max(rez_ireg))  
     This won't work on monochrome monitors, of course.  
     The default is rez_regs=[].  
builtin function, documented at i/rezone.i   line 116  

 rez_solve  
 
  
interpreted function, defined at i/rezone.i   line 1522  

 rez_style  
 
  
interpreted function, defined at i/rezone.i   line 1258  

 rez_test  
 
  
interpreted function, defined at i/rezone.i   line 1565  

 rez_toggle  
 
  
interpreted function, defined at i/rezone.i   line 261  

             rez_zoom  
 
     Change limits after setting rez_mesh.  
     There are two modes of operation:  
     (1) P-mode:  
         Click on a point to magnify or demagnify about that point.  
         Drag the point to move it to a different position in the  
         viewport.  The left button zooms in (magnifies by 1.5), the  
         right button zooms out (demagnifies by 1.5), and the middle  
         button pans (no magnification change).  If you click just  
         below or just above the tick marks, only the x coordinate  
         is changed; clicking just to the left or just to the right  
         of the viewport changes only the y coordinate.  
     (2) R-mode:  
         Left drag out a rectangle to set the limits to that rectangle.  
         Right drag out a rectangle to cram the entire current viewport  
         into that rectangle (an analog to zooming out).  
         Middle drag to pan as in P-mode (the rubber band rectangle is  
         meaningless in this case).  
      Click the [R-mode] (or [P-mode]) button to change modes.  
      Click the [OK] button when you are satisfied with the limits.  
      Click the [Undo] button to remove the effect of the previous  
      zoom-click.  Up to 100 successive undo operations are allowed.  
      Click the [Polar] button to toggle polar coordinates.  The  
      vertical axis will be theta, and the horizontal axis radius.  
      The polar coordinate origin will be at (zt,rt) = (0,0).  
      Click the [Next], [Prev], or [First] buttons to focus in on  
      zones which are bowtied or chevroned.  These zones are marked  
      by a B or a C, respectively (if rez_mark is set).  
interpreted function, defined at i/rezone.i   line 1113  

             rezone, filename  
 
       -or- rezone  
     Invoke the mouse-driven rezoner.  Input is taken from variables  
     rt, zt, and ireg in the file FILENAME (which is prompted for if  
     omitted).  Output is written to a different file as rt, zt, and  
     ireg.  The output file also contains copies rez_rt, rez_zt, and  
     rez_ireg in case the mesh under a different name is desirable,  
     as well as rez_rt0, rez_zt0, and rez_ireg0, which are the original  
     mesh.  
     If you click on [Escape], you may continue rezoning where you left  
     off by typing   rezone   with no arguments.  
     When you are finished, click [OK] to write the output file.  
     Use [Zoom or Pan] and [Set Styles] to change the plot limits or  
     line colors and styles.  The [Zoom or Pan] screen has buttons which  
     "warp" you to each bowtied or chevroned "problem" zone, as well as  
     a button to toggle between rectangular and polar coordinates.  
     Click [Drag Points] to drag points one at a time with the mouse.  
     Click [Adjust Line] to smooth the points on logical line segments.  
     You first click on the endpoints P and Q, then click a button to  
     smooth or equal space the poionts between P and Q, or drag any  
     point between P and Q to establish equal ratio zones ("ER" operation).  
     Click [Adjust Region] to smooth the points in logically rectangular  
     regions.  You first click on the opposite corners P and R of the  
     rectangle PQRS, then click a button to smooth the interior points,  
     or click on a point on one of the four edges to transfer the spacing  
     on that edge throughout the region PQRS ("EQ" operation).  
     The [Undo] (or [Redo]) button removes the effect of the most  
     recent drag points, adjust line, or adjust region operation.  
     Hints:  
     (0) After [Escape], the current mesh is in the variables  
         rez_zt, rez_rt, and rez_ireg.  You can change these  
         variables "by hand" before restarting rezone to make  
         algebraic adjustments.  
     (1) Switch to polar coordinates during an [Adjust Line] or  
         [Adjust Region] in order to get points to lie along a  
         circular arc.  If your center point is not (0,0), you  
         will need to [Escape] and subtract your center point  
         from the rez_zt and rez_rt variables yourself, then  
         [Escape] a second time to restore the proper coordinates  
         before you write the output file.  
     (2) You can select a center point as the second point during  
         [Adjust Line] or [Adjust Region].  When you do this, the  
         K (or L) value of this second point will be the same as  
         that of the first point -- otherwise there is no way to  
         distinguish among all of the logical points at the center.  
         In an [Adjust Region], the center point will be labeled  
         Q instead of R as usual, and you will need to choose a  
         third point (S) to complete the rectangle PQRS.  
     (3) If you set the variable rez_color=1 before you include  
         rezone.i, you will get K lines and L lines drawn in different  
         colors instead of the default (which is K lines dashdot and  
         L lines solid).  
     (4) If you have a color monitor, you can set rez_regs before  
         invoking rezone in order to highlight a list of regions.  
     The ALL keyword will be passed to the nbow function, which will  
     not be called if the QUIET keyword is non-nil and non-zero.  By  
     default, a short summary of bowtied and chevroned zones is printed.  
     If you need help on how to use one of the screens, try getting  
     help on the appropriate on of these see-also topics, e.g.-  
        help, rez_style  
     to get help on the [Set Styles] screen.  
interpreted function, defined at i/rezone.i   line 294  

             rgb = rgb_read()  
          or rgb = rgb_read(n)  
 
     Read contents of current graphics window, or of graphics window N.  
     RGB is a 3xNXxNY array of char where NXxNY is the current shape of  
     the window in pixels.  RGB(1,,) is the red component, RGB(2,,) is  
     the green component, and RGB(3,,) is the blue component, with 0  
     black and 255 full intensity.  RGB(,,1) is the top row of the  
     window, RGB(,,2) the second row, and so on to RGB(,,0), which is  
     the bottom row.  (So RGB(,,::-1) to pli redraws a copy.)  
builtin function, documented at i0/graph.i   line 1376  

             y_at_x_plus_dx= rk4(y,dydx, x,dx, derivative)  
 
     takes a single 4th order Runge-Kutta step from X to X+DX.  
     DERIVATIVE(y,x) is a function returning dydx; the input DYDX  
     is DERIVATIVE(y,x) at the input (X,Y).  This fourth evaluation  
     of DERIVATIVE must be performed by the caller of rk4.  
interpreted function, defined at i/rkutta.i   line 233  

             y= rk_integrate(derivative, y1, x, epsilon, dx1)  
 
     integrates dydx= DERIVATIVE(y,x) beginning at (X(1),Y1) and  
     going to X(0) with fractional error EPSILON.  The result is  
     the value of y at each value in the list X.  If non-nil, DX1  
     will be used as initial guess for the first step size.  
     Otherwise, X(2)-X(1) will be the first step size guess.  
     The list of X values must be monotone -- strictly increasing  
     or strictly decreasing; the Runge-Kutta step sizes are selected  
     adaptively until the next X value would be passed, when the  
     step size is adjusted to complete the step exactly.  
     The external variable rk_maxits (default 10000) is the  
     maximum number of steps rk_integrate will take.  
     If a function rk_yscale(y,dydx,x,dx) exists, it is used  
     to compute an appropriate yscale to give the EPSILON error  
     criterion meaning.  Otherwise, yscale is taken to be:  
        abs(y)+abs(dydx*dx)+1.e-30  
     Based on odeint from Numerical Recipes (Press, et.al.).  
     If the function you are trying to integrate is very  
     smooth, and your X values are fairly far apart, bs_integrate  
     may work better than rk_integrate.  
interpreted function, defined at i/rkutta.i   line 14  

 rk_store  
 
  
interpreted function, defined at i/rkutta.i   line 163  

             y_of_x= rkdumb(derivative, y0,x0, x1,nsteps)  
 
     integrates dydx= DERIVATIVE(y,x) beginning at (X0,Y0) and  
     going to X1 in NSTEPS 4th order Runge-Kutta steps.  The  
     result is dimsof(Y0)-by-(NSTEPS+1) values of y at the points  
     span(X0, X1, NSTEPS+1).  
     If the nosave= keyword is non-zero, the returned value will  
     simply be the final y value.  
interpreted function, defined at i/rkutta.i   line 184  

 rkqc  
 
  
interpreted function, defined at i/rkutta.i   line 205  

             y1= rkutta(derivative, y0,x0, x1,epsilon, dx0)  
 
     integrates dydx= DERIVATIVE(y,x) beginning at (X0,Y0) and  
     going to X1 with fractional error EPSILON.  The result is  
     the value of y at X1.  DX0 will be used as the initial guess  
     for a step size.  
     If the external variable rk_nstore is >0, rk_y and rk_x  
     will contain up to rk_nstore intermediate values after the  
     call to rkutta.  Consider using rk_integrate if you need  
     this feature; using rk_nstore gives you the results at  
     intermediate values which will tend to be closer where  
     the Runge-Kutta step size was smaller, while rk_integrate  
     forces you to specify precisely which x values you want.  
     The external variable rk_maxits (default 10000) is the  
     maximum number of steps rkutta will take.  The variable  
     rk_minstep (default 0.0) is the minimum step size.  The  
     variable rk_maxstep (default 1.e35) is the maximum step  
     size, which you may need if you are storing intermediate  
     values (particularly with bstoer).  
     If a function rk_yscale(y,dydx,x,dx) exists, it is used  
     to compute an appropriate yscale to give the EPSILON error  
     criterion meaning.  Otherwise, yscale is taken to be:  
        abs(y)+abs(dydx*dx)+1.e-30  
     Based on odeint from Numerical Recipes (Press, et.al.).  
     If the function you are trying to integrate is very  
     smooth, bstoer will probably work better than rkutta.  
interpreted function, defined at i/rkutta.i   line 52  

 rm_hist  
 
  
interpreted function, defined at i/testb.i   line 68  

 rmdir  
 
builtin function, documented at i0/std.i   line 1703  

             roll(x, ljoff, rjoff)  
          or roll, x, ljoff, rjoff  
          or roll(x)  
          or roll, x  
 
     "rolls" selected dimensions of the array X.  The roll offsets  
     LJOFF and RJOFF (both optional) work in the same fashion as the  
     LJDIR and RJDIR arguments to the fft function:  
        A scalar LJDIR (and nil RJDIR) rolls all dimensions of X by  
        the specified offset.  
        Otherwise, the elements of the LJDIR vector [ljoff1, ljoff2, ...]  
        are used as the roll offsets for the first, second, etc.  
        dimensions of X.  
        Similarly, the elements of the RJDIR vector [..., rjoff1, rjoff0]  
        are matched to the final dimensions of X, so the next to last  
        dimension is rolled by rjoff1 and the last dimension by rjoff0.  
        As a special case (mostly for use with the fft function), if  
        both LJDIR and RJDIR are nil, every dimension is rolled by  
        half of its length.  Thus,  
           roll(x)  
        it equivalent to  
           roll(x, dimsof(x)(2:0)/2)  
     The result of the roll function is complex if X is complex, otherwise  
     double (i.e.- any other array type is promoted to type double).  If  
     roll is invoked as a subroutine, the operation is performed in place.  
interpreted function, defined at i0/fft.i   line 254  

             integral= romberg(function, a, b)  
          or integral= romberg(function, a, b, epsilon)  
 
     returns the integral of FUNCTION(x) from A to B.  If EPSILON is  
     given, Simpson's rule is refined until that fractional accuracy  
     is obtained.  EPSILON defaults to 1.e-6.  
     If the notvector= keyword is supplied and non-zero, then FUNCTION  
     may not be called with a list of x values to return a list of  
     results.  By default, FUNCTION is assumed to be a vector function.  
     If the function is not very smooth, simpson may work better.  
interpreted function, defined at i/romberg.i   line 10  

             rot3, xa,ya,za  
 
     rotate the current 3D plot by XA about viewer's x-axis,  
     YA about viewer's y-axis, and ZA about viewer's z-axis.  
interpreted function, defined at i/pl3d.i   line 57  

             plt, rotext(text,path), x, y  
 
     return TEXT string as is (PATH=0), reversed (PATH=1), reversed and  
     with a '\n' between each character, or with '\n' between characters  
     (PATH=3).  When plotted, these strings correspond to the original  
     meaning of the text path= keyword.  That is, successive characters  
     will appear to the right, left, up, or down according to whether  
     PATH is 0, 1, 2, or 3  
interpreted function, defined at i/txpath.i   line 12  

 rzextr  
 
  
interpreted function, defined at i/rkutta.i   line 338