section r of routines in global.i

all functions - r

random


    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 758

SEE ALSO: rez_mesh

rezone


    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

SEE ALSO: rez_all, rez_drag, rez_ladj, rez_radj, rez_zoom, rez_style,
rez_color, rez_regs, rez_adjust_mesh, toy_mesh

rgb_read


    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 1452

rk4


    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

rk_integrate


    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

SEE ALSO: rkutta, bs_integrate, rk_maxits, rk_minstep, rk_maxstep, rk_ngood,
rk_nbad, rkdumb, rk4

rk_store


    rk_store  


  
     Interpreted function, defined at i/rkutta.i   line 163

rkdumb


    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


    rkqc  


  
     Interpreted function, defined at i/rkutta.i   line 205

rkutta


    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

SEE ALSO: rk_integrate, bstoer, rk_nstore, rk_maxits, rk_minstep, rk_maxstep,
rk_ngood, rk_nbad, rkdumb, rk4

rmdir


    rmdir  


Builtin function, documented at i0/std.i   line 2478

SEE mkdir

roll


    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