all functions - t
|
tan
|
tan builtin function, documented at i0/std.i line 518 | |
| SEE | sin | |
|
tanh
|
tanh builtin function, documented at i0/std.i line 557 | |
| SEE | sinh | |
|
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 1-D
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 1-D
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
| |
|
testLU
|
testLU interpreted function, defined at i/testm.i line 116 | |
|
testQR
|
testQR interpreted function, defined at i/testm.i line 152 | |
|
testSV
|
testSV interpreted function, defined at i/testm.i line 209 | |
|
testSVD
|
testSVD interpreted function, defined at i/testm.i line 176 | |
|
testTD
|
testTD interpreted function, defined at i/testm.i line 91 | |
|
test_clog
|
test_clog interpreted function, defined at i/testb.i line 260 | |
|
test_full
|
test_full interpreted function, defined at i/testb.i line 219 | |
|
test_hist
|
test_hist interpreted function, defined at i/testb.i line 302 | |
|
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
| |
|
tester1
|
tester1 interpreted function, defined at i/testb.i line 74 | |
|
tester2
|
tester2 interpreted function, defined at i/testb.i line 122 | |
|
tester3
|
tester3 interpreted function, defined at i/testb.i line 174 | |
|
tester4
|
tester4 ter3 interpreted function, defined at i/testb.i line 227 | |
|
tester5
|
tester5 interpreted function, defined at i/testb.i line 279 | |
|
tester6
|
tester6 interpreted function, defined at i/testb.i line 362 | |
|
testg
|
testg
runs a Yorick near-equivalent 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 (NI-1)-by-(NJ-1)-by-(nk-1)
logically rectangular grid of cells into the list of
2-by-2-by-2-by-numberof(LIST) cell corner indices in the
corresponding NI-by-NJ-by-nk 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_ecliptic
|
to_ecliptic interpreted function, defined at i/kepler.i line 157 | |
|
to_hsv
|
hsv= to_hsv(rgb)
or hsv= to_hsv([r,g,b])
return the HSV representation of the n-by-3 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 non-0, 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 vice-versa; 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 n-by-3 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 | |
|
tokenize_line
|
tokenize_line interpreted function, defined at i/make.i line 416 | |
|
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(i-1) * TRANSP(i)
emissivity(i) = emissivity(i-1) * 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 2-by-dimsof(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 non-nil and non-zero, the group dimension is second.
In either case, the result will be ngroup-by-2-by-dimsof(NLIST).
track_solve is the higher-level 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_ray-path | |
|
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,..., ...]
[s1-s0,s2-s1,s3-s2,..., s1-s0,s2-s1,s3-s2,..., ...]
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]-
by-dimsof(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 non-zero 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 mesh-sized 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 2-by-dimsof(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 self-emission 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 non-nil and non-zero, the group dimension is last.
In either case, the result will be ngroup-by-2-by-dimsof(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. Non-positive 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
| |
|
trapezoid
|
trapezoid interpreted function, defined at i/romberg.i line 95 | |
|
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 | |