Home
Manual
Packages
Global Index
Keywords
Quick Reference

all functions  t
test1

test1
or test1, npass
Track a mock "ablation front" as it propagates through a mesh.
If NPASS is given, the calculation is repeated that many
times. The zoning, densities, temperatures, pressures, and
velocities are all computed arbitrarily, but the number of zones
and groups are taken to be representative of a typical 1D
ablation calculation. */
interpreted function, defined at i/test1.i line 12

test2

test2
or test2, npass
Given a slab divided into zones by parallel planes, and given a
set of photon group boundary energies, compute the contribution of
each zone to the radiation flux emerging from one surface of the
slab. If NPASS is given, the calculation is repeated that many
times. The zoning, photon group structure, opacities, and source
functions are all computed arbitrarily, but the number of zones
and groups are taken to be representative of a typical 1D
radiation transport calculation. */
interpreted function, defined at i/test2.i line 10

test3

test3
or test3, npass
Computes the ratio r which solves 1 + r^2 + r^3 +...+ r^n = s,
given n and s. If NPASS is given, the calculation is repeated
that many times (actually the equation is solved many times for
each pass). The worker routine invgeom can actually be
vectorized; the vector version is gseries_r in series.i. */
interpreted function, defined at i/test3.i line 10

testb

testb
or testb, 1 (prints yorick_stats)
Perform systematic test of all features of Yorick's binary I/O
package. This extends the simple test in testp.i.
interpreted function, defined at i/testb.i line 14

testg

testg
runs a Yorick nearequivalent of Steve Langer's grbench graphics
timing benchmark.
interpreted function, defined at i/testg.i line 11

SEE ALSO:

lissajous,
grtest,
txtest

testlp

testlp
Run a benchmark of Yorick's LUsolve routine similar to the
Linpack benchmark.
interpreted function, defined at i/testlp.i line 11

testm

testm
interpreted function, defined at i/testm.i line 10

timer

timer, elapsed
or timer, elapsed, split
updates the ELAPSED and optionally SPLIT timing arrays. These
arrays must each be of type array(double,3); the layout is
[cpu, system, wall], with all three times measured in seconds.
ELAPSED is updated to the total times elapsed since this copy
of Yorick started. SPLIT is incremented by the difference between
the new values of ELAPSED and the values of ELAPSED on entry.
This feature allows for primitive code profiling by keeping
separate accounting of time usage in several categories, e.g.
elapsed= total= cat1= cat2= cat3= array(double, 3);
timer, elapsed0;
elasped= elapsed0;
... category 1 code ...
timer, elapsed, cat1;
... category 2 code ...
timer, elapsed, cat2;
... category 3 code ...
timer, elapsed, cat3;
... more category 2 code ...
timer, elapsed, cat2;
timer, elapsed0, total;
The wall time is not absolutely reliable, owning to possible
rollover at midnight.
builtin function, documented at i0/std.i line 2639

SEE ALSO:

timestamp,
timer_print

timer_print

timer_print, label1, split1, label2, split2, ...
or timer_print
or timer_print, label_total
prints out a timing summary for splits accumulated by timer.
timer_print, "category 1", cat1, "category 2", cat2,
"category 3", cat3, "total", total;
interpreted function, defined at i0/std.i line 2667

SEE ALSO:

timer

timestamp

timestamp()
returns string of the form "Sun Jan 3 15:14:13 1988"  always
has 24 characters.
builtin function, documented at i0/std.i line 2632

SEE ALSO:

timer

to_corners3

to_corners(list, ni, nj)
convert a LIST of cell indices in an (NI1)by(NJ1)by(nk1)
logically rectangular grid of cells into the list of
2by2by2bynumberof(LIST) cell corner indices in the
corresponding NIbyNJbynk list of vertices.
interpreted function, defined at i/slice3.i line 488

to_db

to_db(signal, ref)
or to_db(signal)
return 20.*log10(abs(SIGNAL)/REF), the number of decibels
corresponding to the input SIGNAL. REF defaults to 1.0.
interpreted function, defined at i/filter.i line 510

SEE ALSO:

fil_response,
to_phase

to_hsv

hsv= to_hsv(rgb)
or hsv= to_hsv([r,g,b])
return the HSV representation of the nby3 array of RGB colors
rgb: red, green, blue from 0 to 255
hsv: h= hue in degrees, red=0, green=120, blue=240
s= saturation from 0 (gray) to 1 (full hue)
v= value from 0 (black) to 1 (full intensity)
s= 1  min(r,g,b)/max(r,g,b)
v= max(r,g,b)
interpreted function, defined at i/color.i line 111

SEE ALSO:

to_rgb

to_phase

to_phase(signal)
or to_phase(signal, 1)
return atan(SIGNAL.im,SIGNAL.re), the phase of the input SIGNAL.
If the second argument is present and non0, the phase will be in
degrees; by default the phase is in radians.
To_phase attempts to unroll any jumps from 180 to +180 degrees
or viceversa; zero phase will be taken somewhere near the middle
of the signal. The external variable to_phase_eps controls the
details of this unrolling; you can turn off unrolling by setting
to_phase_eps=0.0 (initially it is 0.3).
interpreted function, defined at i/filter.i line 524

SEE ALSO:

fil_response,
to_phase

to_rgb

rgb= to_rgb(hsv)
or rgb= to_rgb([h,s,v])
return the RGB representation of the nby3 array of HSV colors
rgb: red, green, blue from 0 to 255
hsv: h= hue in degrees, red=0, green=120, blue=240
s= saturation from 0 (gray) to 1 (full hue)
v= value from 0 (black) to 1 (full intensity)
s= 1  min(r,g,b)/max(r,g,b)
v= max(r,g,b)/255
interpreted function, defined at i/color.i line 68

SEE ALSO:

to_hsv

toy_mesh

toy_mesh, filename
generates a toy mesh in the file FILENAME in order to be able to
play with the rezone function. (FILENAME must be a string enclosed
in double quotes, of course.)
interpreted function, defined at i/rezone.i line 13

SEE ALSO:

rezone

track_integ

result= track_integ(nlist, transp, selfem, last)
integrates a transport equation by doing the sums:
transparency(i) = transparency(i1) * TRANSP(i)
emissivity(i) = emissivity(i1) * TRANSP(i) + SELFEM(i)
returning only the final values transparency(n) and emissivity(n).
The NLIST is a list of n values, so that many transport integrals
can be performed simultaneously; sum(NLIST) = numberof(TRANSP) =
numberof(SELFEM). The result is 2bydimsof(NLIST).
If TRANSP is nil, result is dimsof(NLIST) sums of SELFEM.
If SELFEM is nil, result is dimsof(NLIST) products of TRANSP.
TRANSP and SELFEM may by 2D to do multigroup integrations
simultaneously. By default, the group dimension is first, but
if LAST is nonnil and nonzero, the group dimension is second.
In either case, the result will be ngroupby2bydimsof(NLIST).
track_solve is the higherlevel interface.
interpreted function, defined at i0/hex.i line 290

SEE ALSO:

track_reduce,
track_solve,
track_solve

track_rays

ray_paths= track_rays(rays, mesh, slimits)
returns array of Ray_Path structs representing the progress of
RAYS through the MESH between the given SLIMITS.
interpreted function, defined at i0/drat.i line 1244

SEE ALSO:

Ray_Path,
integ_flat,
get_raypath

track_reduce

nlist= track_reduce(c, s)
or nlist= track_reduce(c, s, rays, slimits)
compresses the C and S returns from the tracking routines (see
hex5_track) to the following form:
[cell1,cell2,cell3,..., cell1,cell2,cell3,..., ...]
[s1s0,s2s1,s3s2,..., s1s0,s2s1,s3s2,..., ...]
returning nlist as
[#hits, #hits, ...]
In this form, any negative #hits are combined with the preceding
positive values, and #hits=1 (indicating a miss) appear as #hits=0
in nlist. Hence, nlist always has exactly Nrays elements.
If RAYS is supplied, it is used to force the dimensions of the
returned nlist to match the dimensions of RAYS (the value of RAYS
is never used). The RAYS argument need not have the trailing 2
dimension, so if you specified RAYS as [P,Q] if the call to
hex5_track, you can use just P or Q as the RAYS argument to
track_reduce.
If SLIMITS is supplied, it should be [smin,smax] or [smin,smax]
bydimsof(nlist) in order to reject input S values outside the
specified limits. The C list will be culled appropriately, and
the first and last returned ds values adjusted.
With a nonzero flip= keyword, the order of the elements of
C and S within each group of #hits is reversed, so that a
subsequent track_solve will track the ray backwards. If you
use this, both the ray direction input to the tracking routine
and any SLIMITS argument here should refer to the reverse of
the ray you intend to track.
interpreted function, defined at i0/hex.i line 156

SEE ALSO:

hex5_track,
c_adjust,
track_solve,
track_integ

track_solve

result= track_solve(nlist, c, s, akap, ekap, last)
integrates a transport equation for NLIST, C, and S returned
by track_reduce (and optionally c_adjust). The RAYS argument
is used only to set the dimensions of the result. AKAP and
EKAP are meshsized arrays of opacity and emissivity, respectively.
They may have an additional group dimension, as well. The
units of AKAP are 1/length (where length is the unit of S),
while EKAP is (spectral) power per unit area (length^2), where
the power is what ever units you want the result in. The
emission per unit volume of material is EKAP*AKAP; an optically
thick block of material emits EKAP per unit surface.
The NLIST is a list of n values, so that many transport integrals
can be performed simultaneously; sum(NLIST) = numberof(AKAP) =
numberof(EKAP). The result is 2bydimsof(NLIST), where the
first element of the first index is the transmission fraction
through the entire ray path, and the second element of the
result is the selfemission along the ray, which has the same
units as EKAP.
If EKAP is nil, result is dimsof(NLIST)  exactly the same as
the transparency (1st element of result) when both EKAP and AKAP
are specified.
If AKAP is nil, result is dimsof(NLIST). In this case, EKAP
must have units of emission per unit volume instead of per unit
area; the result will be the sum of EKAP*S along each ray.
AKAP and EKAP may by 2D to do multigroup integrations
simultaneously. By default, the group dimension is first, but
if LAST is nonnil and nonzero, the group dimension is last.
In either case, the result will be ngroupby2bydimsof(NLIST).
To use in conjuction with hex5_track, one might do this:
c= hex5_track(mesh, rays, s);
nlist= track_reduce(c, s, rays);
c_adjust, c, mesh; // if necessary
result= track_solve(nlist, c, s, akap, ekap);
interpreted function, defined at i0/hex.i line 349

SEE ALSO:

track_reduce,
hex5_track

transpose

transpose(x)
or transpose(x, permutation1, permutation2, ...)
transpose the first and last dimensions of array X. In the second
form, each PERMUTATION specifies a simple permutation of the
dimensions of X. These permutations are compounded left to right
to determine the final permutation to be applied to the dimensions
of X. Each PERMUTATION is either an integer or a 1D array of
integers. A 1D array specifies a cyclic permutation of the
dimensions as follows: [3, 5, 2] moves the 3rd dimension to the
5th dimension, the 5th dimension to the 2nd dimension, and the 2nd
dimension to the 3rd dimension. Nonpositive numbers count from the
end of the dimension list of X, so that 0 is the final dimension,
1 in the next to last, etc. A scalar PERMUTATION is a shorthand
for a cyclic permutation of all of the dimensions of X. The value
of the scalar is the dimension to which the 1st dimension will move.
Examples: Let x have dimsof(x) equal [6, 1,2,3,4,5,6] in order
to be able to easily identify a dimension by its length. Then:
dimsof(x) == [6, 1,2,3,4,5,6]
dimsof(transpose(x)) == [6, 6,2,3,4,5,1]
dimsof(transpose(x,[1,2])) == [6, 2,1,3,4,5,6]
dimsof(transpose(x,[1,0])) == [6, 6,2,3,4,5,1]
dimsof(transpose(x,2)) == [6, 6,1,2,3,4,5]
dimsof(transpose(x,0)) == [6, 2,3,4,5,6,1]
dimsof(transpose(x,3)) == [6, 5,6,1,2,3,4]
dimsof(transpose(x,[4,6,3],[2,5])) == [6, 1,5,6,3,2,4]
builtin function, documented at i0/std.i line 1064

tspline

d2ydx2= tspline(tension, y, x)
or yp= tspline(tension, d2ydx2, y, x, xp)
or yp= tspline(tension, y, x, xp)
computes a tensioned spline curve passing through the points (X, Y).
The first argument, TENSION, is a positive number which determines
the "tension" in the spline. In a cubic spline, the second derivative
of the spline function varies linearly between the points X. In the
tensioned spline, the curvature is concentrated near the points X,
falling off at a rate proportional to the tension. Between the points
of X, the function varies as:
y= C1*exp(k*x) + C2*exp(k*x) + C3*x + C4
The parameter k is proportional to the TENSION; for k>0, the function
reduces to the cubic spline (a piecewise cubic function), while for
k>infinity, the function reduces to the piecewise linear function
connecting the points. The TENSION argument may either be a scalar
value, in which case, k will be TENSION*(numberof(X)1)/(max(X)min(X))
in every interval of X, or TENSION may be an array of length one less
than the length of X, in which case the parameter k will be
abs(TENSION/X(dif)), possibly varying from one interval to the next.
You can use a variable tension to flatten "bumps" in one interval
without affecting nearby intervals. Internally, tspline forces
k*X(dif) to lie between 0.01 and 100.0 in every interval, independent
of the value of TENSION. Typically, the most dramatic variation
occurs between TENSION of 1.0 and 10.0.
With three arguments, Y and X, spline returns the derivatives D2YDX2 at
the points, an array of the same length as X and Y. The D2YDX2 values
are chosen so that the tensioned spline function returned by the five
argument call will have a continuous first derivative.
The X array must be strictly monotonic; it may either increase or
decrease.
The values Y and the derivatives D2YDX2 uniquely determine a tensioned
spline function, whose value is returned in the five argument form.
In this form, tspline is analogous to the piecewise linear interpolator
interp; usually you will regard it as a continuous function of its
fifth (or fourth) argument, XP.
The XP array may have any dimensionality; the result YP will have
the same dimensions as XP.
The D2YDX2 argument will normally have been computed by a previous call
to the three argument tspline function. If you will be computing the
values of the spline function for many sets of XP, use this five
argument form.
If you only want the tspline evaluated at a single set of XP, use the
four argument form. This is equivalent to:
yp= tspline(tension, tspline(tension,y,x), y, x, xp)
The keywords DYDX1 and DYDX0 can be used to set the values of the
returned DYDX(1) and DYDX(0)  the first and last values of the
slope, respectively. If either is not specified or nil, the slope at
that end will be chosen so that the second derivative is zero there.
The function tspline (tensioned spline) gives an interpolation
function which lies between spline and interp, at the cost of
requiring you to specify another parameter (the tension).
interpreted function, defined at i/spline.i line 122

SEE ALSO:

interp,
tspline

txtest

txtest
txtest, n
Print some tests of Yorick's plt command. Start with the nth
page in the second form.
interpreted function, defined at i/testg.i line 527

typeof

typeof(object)
returns a string describing the type of object. For the basic
data types, these are "char", "short", "int", "long", "float",
"double", "complex", "string", "pointer", "struct_instance",
"void", "range", "struct_definition", "function", "builtin",
"stream" (for a binary stream), and "text_stream".
builtin function, documented at i0/std.i line 399

SEE ALSO:

structof,
dimsof,
sizeof,
numberof,
nameof

