|
|
|
|
|
|
|
|
|
backup
|
unknown type function, documented at startup/std.i line 1478 | |
| SEE |
bookmark |
|
|
baget
|
baget(file, varname)
read and return the (first) variable named VARNAME in FILE.
The obasis function opens files read-only. If you want to update
a PFB Basis-generated PDB file without altering its "@decorated"
variable names, open the file with updateb, then use baset to
modify variables. Since you can only change the entire variable
with baset, you may want to read it first with baget.
unknown type function, documented at include/basfix.i line 123
| |
| SEE ALSO: |
obasis, |
|
|
baset
|
baset, file, varname, value
set the (first) variable named VARNAME in FILE to VALUE.
The obasis function opens files read-only. If you want to update
a PFB Basis-generated PDB file without altering its "@decorated"
variable names, open the file with updateb, then use baset to
modify variables. Since you can only change the entire variable
with baset, you may want to read it first with baget.
unknown type function, documented at include/basfix.i line 100
| |
| SEE ALSO: |
obasis, |
|
|
batch
|
batch, 1
batch, 0
batch()
turns on, turns off, or tests for batch mode, respectively.
If yorick is started with the command line:
yorick -batch batch_include.i ...
then batch mode is turned on, the usual custom.i startup file is
skipped, and the file batch_include.i is parsed and executed. The
-batch and batch_include.i command line arguments are removed from
the list returned by get_argv(). These must be the first two
arguments on the command line.
In batch mode, any error will terminate Yorick (as by the quit
function) rather than entering debug mode. Also, any attempt to
read from the keyboard is an error.
unknown type function, documented at startup/std.i line 2476
| |
| SEE ALSO: |
process_argv, |
|
|
bc0_v
|
|
| SEE |
shock |
|
bc0_v
|
|
| SEE |
sound |
|
bessi
|
bessi(n, x)
returns Bessel function In of order N at points X. N must be scalar.
unknown type function, documented at include/bessel.i line 313
| |
| SEE ALSO: |
bessk, |
|
|
bessi0
|
bessi0(x)
returns Bessel function I0 at points X.
unknown type function, documented at include/bessel.i line 258
| |
| SEE ALSO: |
bessi |
|
|
bessi1
|
bessi1(x)
returns Bessel function I1 at points X.
unknown type function, documented at include/bessel.i line 285
| |
| SEE ALSO: |
bessi |
|
|
bessj
|
bessj(n, x)
returns Bessel function Jn of order N at points X. N must be scalar.
unknown type function, documented at include/bessel.i line 94
| |
| SEE ALSO: |
bessy, |
|
|
bessj0
|
bessj0(x)
returns Bessel function J0 at points X.
unknown type function, documented at include/bessel.i line 28
| |
| SEE ALSO: |
bessj |
|
|
bessj1
|
bessj1(x)
returns Bessel function J1 at points X.
unknown type function, documented at include/bessel.i line 61
| |
| SEE ALSO: |
bessj |
|
|
bessk
|
bessk(n, x)
returns Bessel function Kn of order N at points X. N must be scalar.
unknown type function, documented at include/bessel.i line 411
| |
| SEE ALSO: |
bessi, |
|
|
bessk0
|
bessk0(x)
returns Bessel function K0 at points X.
unknown type function, documented at include/bessel.i line 359
| |
| SEE ALSO: |
bessk |
|
|
bessk1
|
bessk1(x)
returns Bessel function K1 at points X.
unknown type function, documented at include/bessel.i line 385
| |
| SEE ALSO: |
bessk |
|
|
bessy
|
bessy(n, x)
returns Bessel function Yn of order N at points X. N must be scalar.
unknown type function, documented at include/bessel.i line 232
| |
| SEE ALSO: |
bessj, |
|
|
bessy0
|
bessy0(x)
returns Bessel function Y0 at points X.
unknown type function, documented at include/bessel.i line 165
| |
| SEE ALSO: |
bessy |
|
|
bessy1
|
bessy1(x)
returns Bessel function Y1 at points X.
unknown type function, documented at include/bessel.i line 198
| |
| SEE ALSO: |
bessy |
|
|
best_rays
|
best_rays(rays)
returns 5-element (x,y,z,theta,phi) 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 5.
The "best" coordinate system is the easiest to visualize:
(x,y,z) represents any point on the ray, while (theta,phi)
represents the ray direction in standard spherical coordinates
relative to the +z-axis. Namely, theta is the angle from the
+z-direction to the ray direction (between 0 and pi), and phi is
the counterclockwise angle from the +x-axis to the projection of
the ray direction into the xy-plane, assuming xyz is a right-handed
coordinate system.
As a specification of a ray, this system is doubly redundant because
the point (x,y,z) could be any point on the ray, and the underlying
mesh through which the ray propagates is cylindrically symmetric about
the z-axis.
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
(x,y,z,theta,phi) 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.
unknown type function, documented at include/rays.i line 73
| |
| SEE ALSO: |
form_rays, picture_rays |
|
|
beta
|
beta(z,w)
returns the beta function gamma(z)gamma(w)/gamma(z+w)
unknown type function, documented at include/gamma.i line 67
| |
| SEE ALSO: |
ln_gamma, |
|
|
bico
|
bico(n,k)
returns the binomial coefficient n!/(k!(n-k)!) as a double.
unknown type function, documented at include/gamma.i line 58
| |
| SEE ALSO: |
ln_gamma, |
|
|
bookmark
|
backup, f
or bmark= bookmark(f)
...
backup, f, bmark
back up the text stream F, so that the next call to the read
function returns the same line as the previous call to read
(note that you can only back up one line). If the optional
second argument BMARK is supplied, restores the state of the
file F to its state at the time the bookmark function was
called.
After a matching failure in read, use the single argument form
of backup to reread the line containing the matching failure.
unknown type function, documented at startup/std.i line 1478
| |
| SEE ALSO: |
read, |
|
|
bowtie
|
map= bowtie(rt, zt)
or map= bowtie(rt, zt, ireg)
returns a "bowtie map" for the quadrilateral mesh defined by
RT, ZT, and (optionally) IREG. If IREG is present, it should be
an integer array of the same dimensions as RT and ZT; its first
row and column are ignored, otherwise each non-zero element of
IREG marks an existing zone in the mesh. (An IREG with one fewer
row and column than RT and ZT will also be accepted.) If IREG
is omitted, every zone is presumed to exist.
The returned MAP is a 2-D integer array with one fewer row and
column than RT and ZT. It's values have the following meanings:
2 marks a convex zone with positive area
1 marks a concave (boomerang) zone with positive area
0 marks a bowtied zone
-1 marks a concave (boomerang) zone with negative area
-2 marks a convex zone with negative area
-9 marks a non-existent zone
Use the nbow function to print the results.
unknown type function, documented at include/bowtie.i line 42
| |
| SEE ALSO: |
nbow |
|
|
brighten
|
brighten, factor
or brighten
brighten the current palette by the specified FACTOR.
The FACTOR is the slope of the transfer function for the color value
(see to_hsv for a description of the hsv color system); a value of
1.0 always remains 1.0, but values near 0.0 change by FACTOR.
FACTOR= 1.0 is a no-op. The default factor is 4.0.
unknown type function, documented at include/color.i line 57
| |
| SEE ALSO: |
dump_palette |
|
|
bs_integrate
|
y= bs_integrate(derivative, y1, x, epsilon, dx1)
Bulirsch-Stoer integrator, otherwise identical to rk_integrate
routine. All of the options for rk_integrate work here as well.
Based on odeint from Numerical Recipes (Press, et.al.).
If the function you are trying to integrate is not very
smooth, or your X values are closely spaced, rk_integrate
will probably work better than bs_integrate.
unknown type function, documented at include/rkutta.i line 273
| |
| SEE ALSO: |
bstoer, rk_maxstep, |
|
|
bstoer
|
y1= bstoer(derivative, y0,x0, x1,epsilon, dx0)
Bulirsch-Stoer integrator, otherwise identical to rkutta routine.
All of the options for rkutta (rk_nstore, etc.) work here as well.
If the function you are trying to integrate is not very
smooth, rkutta will probably work better than bstoer.
unknown type function, documented at include/rkutta.i line 292
| |
| SEE ALSO: |
rkutta, rk_maxstep, |
|
|
build_dimlist
|
build_dimlist, dimlist, next_argument
build a DIMLIST, as used in the array function. Use like this:
func your_function(arg1, arg2, etc, dimlist, ..)
{
while (more_args()) build_dimlist, dimlist, next_arg();
...
}
After this, DIMLIST will be an array of the form
[#dims, dim1, dim2, ...], compounded from the multiple arguments
in the same way as the array function. If no DIMLIST arguments
given, DIMLIST will be [] instead of [0], which will act the
same in most situations. If that possibility is unacceptible,
you may add
if (is_void(dimlist)) dimlist= [0];
after the while loop.
unknown type function, documented at include/random.i line 67
| |
|
button_build
|
button_build(button)
-or- button_build(button, which)
Returns a Button structure instance, modified interactively to be at
the correct position and to have the correct box half widths, e.g.:
button= button_build(Button(text="label",y=initial_y))
You can either drag the center of the button to a new location
(press down near the center of the button, move the pointer to
where you want the center, and release at the new center point),
or press the "Set Box" or "Done" button. In the "Set Box" mode,
you can either drag a new box over the button, or press "Set Center"
(to return to the original mode) or "Done" button.
Yorick has no way to determine the size of a text string produced
by the plt command, which is why you need to be able to adjust
the size of the box draawn around the text. The idea is to use
button_build to get the buttons where you like, then put those
coordinates into the include file for the mouse-driven function
you are writing.
Also, the input BUTTON may be an array of buttons, and BUTTON(WHICH)
will be the one that is modified. WHICH defaults to 1. By using an
array of buttons, you can see all the other buttons in a group while
you adjust one.
unknown type function, documented at include/button.i line 59
| |
| SEE ALSO: |
Button, |
|
|
button_plot
|
button_plot, button1, button2, ...
plot the specified BUTTONs. Each button in the list may be an array
of Button structs. Void arguments are no-ops.
unknown type function, documented at include/button.i line 143
| |
| SEE ALSO: |
Button, |
|
|
button_test
|
button_test(button, x, y)
true if the BUTTON contains NDC coordinates (X,Y).
unknown type function, documented at include/button.i line 167
| |
| SEE ALSO: |
Button, |
|
|
bytscl
|
bytscl(z)
or bytscl(z, top=max_byte, cmin=lower_cutoff, cmax=upper_cutoff)
returns a char array of the same shape as Z, with values linearly
scaled to the range 0 to one less than the current palette size.
If MAX_BYTE is specified, the scaled values will run from 0 to
MAX_BYTE instead.
If LOWER_CUTOFF and/or UPPER_CUTOFF are specified, Z values outside
this range are mapped to the cutoff value; otherwise the linear
scaling maps the extreme values of Z to 0 and MAX_BYTE.
unknown type function, documented at startup/graph.i line 1193
| |
| SEE ALSO: |
plf, |
|
|
|
|
|
|
|
|
|