all functions - f
|
f_inverse
|
f_inverse(f_and_dfdx, y, x0, x1, xerr)
or f_inverse(f_and_dfdx, y, x0, x1, xerr)
Find values of an inverse function by Newton-Raphson iteration,
backed up by bisection if the convergence seems poor. The
subroutine F_AND_DFDX must be defined as:
func F_AND_DFDX (x, &f, &dfdx)
returning both the function value f(x) and derivative dfdx(x).
If the input x is an array, the returned f and dfdx must have
the same shape as the input x. If F_AND_DFDX always returns
zero dfdx, f_inverse will use bisection.
The result x will have the same shape as the input Y values.
The values of x are constrained to lie within the interval from
X0 to X1; the function value must be on opposite sides of the
required Y at these interval endpoints. The iteration stops
when the root is known to within XERR, or to machine precision
if XERR is nil or zero. X0, X1, and XERR may be arrays conformable
with Y.
f_inverse takes the same number of iterations for every Y value;
it does not notice that some may have converged before others.
interpreted function, defined at i/roots.i line 102
| |
| SEE ALSO: | nraphson | |
|
factorize
|
factorize(x)
return list of prime factors of X and their powers as an n-by-2
array. May include a large non-prime factor if X exceeds 3e9.
In any event, product(result(,1)^result(,2)) will equal abs(X).
X must be a scalar integer type.
interpreted function, defined at i/gcd.i line 83
| |
| SEE ALSO: | gcd, lcm, is_prime | |
|
fflush
|
fflush, file
flush the I/O buffers for the text file FILE. (Binary files are
flushed at the proper times automatically.) You should only need
this after a write, especially to a pipe.
builtin function, documented at i0/std.i line 1204
| |
| SEE ALSO: | write, popen | |
|
fft
|
fft(x, direction)
fft(x, ljdir, rjdir)
or fft(x, ljdir, rjdir, setup=workspace)
returns the complex Fast Fourier Transform of array X.
The DIRECTION determines which direction the transform is in --
e.g.- from time to frequency or vice-versa -- as follows:
DIRECTION meaning
--------- -------
1 "forward" transform (coefficients of exp(+i * 2*pi*kl/N))
on every dimension of X
-1 "backward" transform (coefficients of exp(-i * 2*pi*kl/N))
on every dimension of X
[1,-1,1] forward transform on first and third dimensions of X,
backward transform on second dimension of X (any other
dimensions remain untransformed)
[-1,0,0,1] backward transform on first dimension of X, forward
transform on fourth dimension of X
etc.
The third positional argument, if present, allows the direction
of dimensions of X to be specified relative to the final dimension
of X, instead of relative to the first dimension of X. In this
case, both LJDIR and RJDIR must be vectors of integers -- the
scalar form is illegal:
LJDIR RJDIR meaning
----- ----- -------
[] [1] forward transform last dimension of X
[1] [] forward transform first dimension of X
[] [-1,-1] backward transform last two dimensions of X,
leaving any other dimensions untransformed
[-1,0,0,1] [] backward transform on first dimension of X,
forward transform on fourth dimension of X
[] [-1,0,0,1] backward transform on 4th to last dimension of X,
forward transform on last dimension of X
etc.
Note that the final element of RJDIR corresponds to the last dimension
of X, while the initial element of LJDIR corresponds to the first
dimension of X.
The explicit meaning of "forward" transform -- the coefficients of
exp(+i * 2*pi*kl/N) -- is:
result for j=1,...,n
result(j)=the sum from k=1,...,n of
x(k)*exp(-i*(j-1)*(k-1)*2*pi/n)
where i=sqrt(-1)
Note that the result is unnormalized. Applying the "backward"
transform to the result of a "forward" transform returns N times
the original vector of length N. Equivalently, applying either
the "forward" or "backward" transform four times in succession
yields N^2 times the original vector of length N.
Performing the transform requires some WORKSPACE, which can be
set up beforehand by calling fft_setup, if fft is to be called
more than once with arrays X of the same shape. If no setup
keyword argument is supplied, the workspace allocation and setup
must be repeated for each call.
interpreted function, defined at i0/fft.i line 20
| |
| SEE ALSO: | roll, fft_setup, fft_inplace | |
|
fft_braw
|
fft_braw, n, c, wsave
Swarztrauber's cfftb. You can use this to avoid the additional
2*N storage incurred by fft_setup.
builtin function, documented at i0/fft.i line 237
| |
|
fft_dirs
|
fft_dirs interpreted function, defined at i0/fft.i line 192 | |
|
fft_fraw
|
fft_fraw, n, c, wsave
Swarztrauber's cfftf. You can use this to avoid the additional
2*N storage incurred by fft_setup.
builtin function, documented at i0/fft.i line 228
| |
|
fft_good
|
fft_good(n)
returns the smallest number of the form 2^x*3^y*5^z greater
than or equal to n. An fft of this length will be much faster
than a number with larger prime factors; the speed difference
can be an order of magnitude or more.
For n>100, the worst cases result in a little over a 11% increase
in n; for n>1000, the worst are a bit over 6%; still larger n are
better yet. The median increase for n<=10000 is about 1.5%.
| |
| SEE ALSO: | fft, fft_setup, convol | |
|
fft_good
|
fft_good(n)
returns the smallest number of the form 2^x*3^y*5^z greater
than or equal to n. An fft of this length will be much faster
than a number with larger prime factors; the speed difference
can be an order of magnitude or more.
For n>100, the worst cases result in a little over a 11% increase
in n; for n>1000, the worst are a bit over 6%; still larger n are
better yet. The median increase for n<=10000 is about 1.5%.
| |
| SEE ALSO: | fft, fft_setup, convol | |
|
fft_init
|
fft_init, n, wsave
Swarztrauber's cffti. This actually requires wsave=array(0.0, 4*n+15),
instead of the 6*n+15 doubles of storage used by fft_raw to handle the
possibility of multidimensional arrays. If the storage matters, you
can call cfftf and/or cfftb as the Yorick functions fft_fraw and/or
fft_braw.
builtin function, documented at i0/fft.i line 216
| |
|
fft_inplace
|
fft_inplace, x, direction
or fft_inplace, x, ljdir, rjdir
or fft_inplace, x, ljdir, rjdir, setup=workspace
is the same as the fft function, except that the transform is
performed "in_place" on the array X, which must be of type complex.
interpreted function, defined at i0/fft.i line 94
| |
| SEE ALSO: | fft, fft_setup | |
|
fft_raw
|
fft_raw builtin function, documented at i0/fft.i line 246 | |
|
fft_setup
|
workspace= fft_setup(dimsof(x))
or workspace= fft_setup(dimsof(x), direction)
or workspace= fft_setup(dimsof(x), ljdir, rjdir)
allocates and sets up the workspace for a subsequent call to
fft(X, DIRECTION, setup=WORKSPACE)
or
fft(X, LJDIR, RJDIR, setup=WORKSPACE)
The DIRECTION or LJDIR, RJDIR arguments compute WORKSPACE only for
the dimensions which will actually be transformed. If only the
dimsof(x) argument is supplied, then WORKSPACE will be enough to
transform any or all dimensions of X. With DIRECTION or LJDIR, RJDIR
supplied, WORKSPACE will only be enough to compute the dimensions
which are actually to be transformed. The WORKSPACE does not
depend on the sign of any element in the DIRECTION (or LJDIR, RJDIR),
so you can use the same WORKSPACE for both "forward" and "backward"
transforms.
Furthermore, as long as the length of any dimensions of the array
X to be transformed are present in WORKSPACE, it may be used in
a call to fft with the array. Thus, if X were a 25-by-64 array,
and Y were a 64-vector, the following sequence is legal:
ws= fft_setup(dimsof(x));
xf= fft(x, 1, setup=ws);
yf= fft(y, -1, setup=ws);
The WORKSPACE required for a dimension of length N is 6*N+15 doubles.
interpreted function, defined at i0/fft.i line 137
| |
| SEE ALSO: | fft, dimsof, fft_inplace | |
|
fft_test
|
fft_test interpreted function, defined at i/testm.i line 53 | |
|
fil_analyze
|
fil_analyze, filt, poles, zeroes
given a FILT, return the complex POLES and ZEROES, sorted in
order of increasing imaginary part. The real parts of POLES will
all be negative if the FILT is stable.
interpreted function, defined at i/filter.i line 160
| |
| SEE ALSO: | filter, fil_make | |
|
fil_bessel
|
filt= fil_bessel(np, wc, db)
returns the lowpass Bessel filter with NP poles, normalized
such that at angular frequency WC, the attenuation is DB decibels.
(That is, the attenuation factor is 10^(.05*DB) at WC,
so that to_db(response(filt,WC))==DB.)
A Bessel filter has the most nearly constant group delay time
d(phase)/dw of any filter of the same order. It minimizes pulse
distortion, but does not cut off very rapidly in frequency.
If WC is nil or zero, it defaults to 1.0.
If DB is nil, the filter is normalized such that both the s^0
and s^NP terms are 1, unless the natural= keyword is non-zero,
in which case the filter is normalized such that the group delay
d(phase)/dw is -1 at w=0.
interpreted function, defined at i/filter.i line 178
| |
| SEE ALSO: | filter, fil_analyze | |
|
fil_butter
|
filt= fil_butter(np, wc, db)
returns the lowpass Butterworth filter with NP poles, normalized
such that at angular frequency WC, the attenuation is DB decibels.
(That is, the attenuation factor is 10^(.05*DB) at WC,
so that to_db(response(filt,WC))==DB.)
A Butterworth filter is the best Taylor series approximation to
the ideal lowpass filter (a step in frequency) response at both
w=0 and w=infinity.
For wc=1 and db=10*log10(2), the square of the Butterworth frequency
response is 1/(1+w^(2*np)).
If WC is nil or zero, it defaults to 1.0.
If DB is nil, the filter is normalized "naturally", which is the
same as DB=10*log10(2).
interpreted function, defined at i/filter.i line 226
| |
| SEE ALSO: | filter, fil_analyze, butter | |
|
fil_cauer
|
filt= fil_cauer(np, ripple, atten, wc, db)
or filt= fil_cauer(np, ripple, -skirt, wc, db)
returns the lowpass Cauer (elliptic) filter with NP poles, passband
ripple RIPPLE and stopband attenuation ATTEN decibels, normalized
such that at angular frequency WC, the attenuation is DB decibels.
(That is, the attenuation factor is 10^(.05*DB) at WC,
so that to_db(response(filter,WC))==DB.)
If the third parameter is negative, its absolute value is SKIRT,
the ratio of the frequency at which the stopband attenuation is
first reached to the frequency at which the passband ends (where
the attenuation is RIPPLE). The closer to 1.0 SKIRT is, the
smaller the equivalent ATTEN would be. The external variable
cauer_other is set to ATTEN if you provide SKIRT, and to SKIRT
if you provide ATTEN.
The Cauer filter has NP zeroes as well as NP poles.
Consider the four parameters: (1) filter order, (2) transition
("skirt") bandwidth, (3) passband ripple, and (4) stopband ripple.
Given any three of these, the Cauer filter minimizes the fourth.
If WC is nil or zero, it defaults to 1.0.
If DB is nil, the filter is normalized "naturally", which is the
same as DB=RIPPLE.
interpreted function, defined at i/filter.i line 357
| |
| SEE ALSO: | filter, fil_analyze, cauer | |
|
fil_cheby1
|
filt= fil_cheby1(np, ripple, wc, db)
returns the lowpass Chebyshev type I filter with NP poles, and
passband ripple RIPPLE decibels, normalized such that at
angular frequency WC, the attenuation is DB decibels.
(That is, the attenuation factor is 10^(.05*DB) at WC,
so that to_db(response(filter,WC))==DB.)
A Chebyshev type I filter gives the smallest maximum error over the
passband for any filter that is a Taylor series approximation to
the ideal lowpass filter (a step in frequency) response at
w=infinity. It has NP/2 ripples of amplitude RIPPLE in its passband,
and a smooth stopband.
For wc=1 and db=ripple, the square of the Chebyshev frequency
response is 1/(1+eps2*Tnp(w)), where eps2 = 10^(ripple/10)-1,
and Tnp is the np-th Chebyshev polynomial, cosh(np*acosh(x)) or
cos(np*acos(x)).
If WC is nil or zero, it defaults to 1.0.
If DB is nil, the filter is normalized "naturally", which is the
same as DB=RIPPLE.
interpreted function, defined at i/filter.i line 263
| |
| SEE ALSO: | filter, fil_analyze, cheby1 | |
|
fil_cheby2
|
filt= fil_cheby2(np, atten, wc, db)
returns the lowpass Chebyshev type II filter with NP poles, and
stopband attenuation ATTEN decibels, normalized such that at
angular frequency WC, the attenuation is DB decibels.
(That is, the attenuation factor is 10^(.05*DB) at WC,
so that to_db(response(filter,WC))==DB.)
This is also called an inverse Chebyshev filter, since its poles
are the reciprocals of a Chebyshev type I filter. It has NP zeroes
as well as NP poles.
A Chebyshev type II filter gives the smallest maximum leakage over
the stopband for any filter that is a Taylor series approximation to
the ideal lowpass filter (a step in frequency) response at
w=0. It has NP/2 ripples of amplitude ATTEN in its stopband,
and a smooth passband.
For wc=1 and db=ripple, the square of the inverse Chebyshev frequency
response is 1 - 1/(1+eps2*Tnp(1/w)), where eps2 = 10^(ripple/10)-1 =
1/(10^(atten/10)-1) and Tnp is the np-th Chebyshev polynomial,
cosh(np*acosh(x)) or cos(np*acos(x)).
If WC is nil or zero, it defaults to 1.0.
If DB is nil, the filter is normalized "naturally", which is the
same as DB=ATTEN.
interpreted function, defined at i/filter.i line 305
| |
| SEE ALSO: | filter, fil_analyze, cheby2 | |
|
fil_delay
|
fil_delay(filt)
or fil_delay(filt, 1)
return the group delay d(phase)/dw at w=0 (zero frequency) for
filter FILT. By default, FILT is assumed to be normalized
to an angular frequency (e.g.- radians per second), but if
the 2nd parameter is non-nil and non-0 FILT is assumed to be
normalized to a circular frequency (e.g.- Hz or GHz).
interpreted function, defined at i/filter.i line 93
| |
| SEE ALSO: |
filter,
fil_butter,
fil_bessel,
fil_cheby1,
fil_cheby2, fil_response, to_db, to_phase |
|
|
fil_make
|
filt= fil_make(poles, zeroes)
given the complex POLES and ZEROES, return a FILT. The real
parts of POLES must all be negative to make a stable FILT.
Both POLES and ZEROES must occur in conjugate pairs in order to
make a real filter (the returned filter is always real).
The returned filter always has a0=1 (its DC gain is 1).
interpreted function, defined at i/filter.i line 126
| |
| SEE ALSO: | filter, fil_analyze | |
|
fil_normalize
|
fil_normalize interpreted function, defined at i/filter.i line 473 | |
|
fil_poly
|
fil_poly(c, x)
return c(1) + c(2)*x + c(3)*x^2 + c(4)*x^3 + ...
interpreted function, defined at i/filter.i line 115
| |
|
fil_response
|
fil_response(filt, w)
return the complex response of FILT at the frequencies W.
The frequency scale for W depends on how FILT has been scaled;
filters are rational functions in W.
The to_db and to_phase functions may be useful for extracting
the attenuation and phase parts of the complex response.
interpreted function, defined at i/filter.i line 72
| |
| SEE ALSO: |
filter,
fil_butter,
fil_bessel,
fil_cheby1,
fil_cheby2, fil_delay, to_db, to_phase |
|
|
filter
|
filter(filt, dt, signal)
apply the filter FILT to the input SIGNAL, which is sampled
at times spaced by DT. The filter is assumed to be normalized
to an angular frequency (e.g.- radians per second), unless
DT<0, in which case FILT is assumed to be normalized to a
circular frequency (e.g.- Hz or GHz).
The result will have the same length as SIGNAL; be sure to pad
SIGNAL if you need the response to go beyond that time, or
you can use the pad=n keyword to force the returned result to
have N samples more than SIGNAL.
If the shift= keyword is non-nil and non-0, then the result
is shifted backward in time by the filter group delay at
zero frequency.
The impulse response of the FILT is also assumed to be shorter
than the duration of signal, and SIGNAL is assumed to be sampled
finely enough to resolve the FILT impulse response.
FILT is an array of double, which represents a filter with
a particular finite list of zeroes and poles. See the specific
functions to construct filters from poles and zeroes (fil_make),
or classic Bessel, Butterworth, Chebyshev, inverse Chebyshev, or
Cauer (elliptic) designs. With fil_analyze, you can find the
poles and zeroes of a FILT. The format for FILT is:
FILT is an array of double with the following meanings:
FILT(1) = np = number of poles (integer >= 0)
FILT(2) = nz = number of zeroes (integer >= 0)
FILT(3) = reserved
FILT(4:4+nz) = coefficients for numerator
= [a0, a1, a2, a3, ..., anz]
FILT(5+nz:4+nz+np) = coefficents for denominator (if np>0)
= [b1, b2, b3, ..., bnp]
The Laplace transform (s-transform) of the filter response is
L[FILT] = (a0 + a1*s + a2*s^2 + a3*s^3 + ...) /
( 1 + b1*s + b2*s^2 + b3*s^3 + ...)
interpreted function, defined at i/filter.i line 8
| |
| SEE ALSO: |
filter,
fil_bessel,
fil_butter,
fil_cheby1,
fil_cheby2, fil_cauer, fil_response, fil_make, fil_analyze, to_db, to_phase |
|
|
find_boundary
|
boundary= find_boundary(mesh)
or boundary= find_boundary(mesh, region, sense)
returns an array of 4 pointers representing the boundary of the
MESH, or of a particular REGION of the MESH, with a particular
SENSE -- 0 for counterclockwise in the (r,z)-plane, 1 for
clockwise. The returned arrays are:
*boundary(1) zone index list -- always 1-origin values
*boundary(2) side list 0, 1, 2, or 3
side 0 is from point zone to zone-1, side 1 is
from zone-1 to zone-imax-1
*boundary(3) z values of boundary points
*boundary(4) r values of boundary points
builtin function, documented at i0/drat.i line 1095
| |
| SEE ALSO: | form_mesh, update_mesh | |
|
find_file
|
find_file interpreted function, defined at i/make.i line 463 | |
|
fitlsq
|
yp= fitlsq(y, x, xp)
...
yfit= interp(yp, xp, xfit)
performs a least squares fit to the data points (X, Y). The input
XP are the abcissas of the piecewise linear function passing through
(XP, YP) which is the best fit to the data (X,Y) in a least squares
sense. The XP must be strictly monotone, either increasing or
decreasing. As for interp, the piecewise linear fit is taken to be
constant outside the limits of the XP.
The result YP is linearly interpolated through any consecutive
intervals of XP which contain no data points X, and linearly
extrapolated beyond the extreme values of X (if any of the intervals
of XP lie outside these extremes).
A WEIGHT keyword of the same length as X and Y may be supplied in
order to weight the various data points differently; a typical
WEIGHT function is 1/sigma^2 where sigma are the standard deviations
associated with the Y values.
interpreted function, defined at i/fitlsq.i line 10
| |
| SEE ALSO: | interp | |
|
fitpol
|
yp= fitpol(y, x, xp)
-or- yp= fitpol(y, x, xp, keep=1)
is an interpolation routine similar to interp, except that fitpol
returns the polynomial of degree numberof(X)-1 which passes through
the given points (X,Y), evaluated at the requested points XP.
The X must either increase or decrease monotonically.
If the KEEP keyword is present and non-zero, the external variable
yperr will contain a list of error estimates for the returned values
yp on exit.
The algorithm is taken from Numerical Recipes (Press, et. al.,
Cambridge University Press, 1988); it is called Neville's algorithm.
The rational function interpolator fitrat is better for "typical"
functions. The Yorick implementaion requires numberof(X)*numberof(XP)
temporary arrays, so the X and Y arrays should be reasonably small.
interpreted function, defined at i/fitrat.i line 10
| |
| SEE ALSO: | fitrat, interp | |
|
fitrat
|
yp= fitrat(y, x, xp)
-or- yp= fitrat(y, x, xp, keep=1)
is an interpolation routine similar to interp, except that fitpol
returns the diagonal rational function of degree numberof(X)-1 which
passes through the given points (X,Y), evaluated at the requested
points XP. (The numerator and denominator polynomials have equal
degree, or the denominator has one larger degree.)
The X must either increase or decrease monotonically. Also, this
algorithm works by recursion, fitting successively to consecutive
pairs of points, then consecutive triples, and so forth.
If there is a pole in any of these fits to subsets, the algorithm
fails even though the rational function for the final fit is non-
singular. In particular, if any of the Y values is zero, the
algorithm fails, and you should be very wary of lists for which
Y changes sign. Note that if numberof(X) is even, the rational
function is Y-translation invariant, while numberof(X) odd generally
results in a non-translatable fit (because it decays to y=0).
If the KEEP keyword is present and non-zero, the external variable
yperr will contain a list of error estimates for the returned values
yp on exit.
The algorithm is taken from Numerical Recipes (Press, et. al.,
Cambridge University Press, 1988); it is called the Bulirsch-Stoer
algorithm. The Yorick implementaion requires numberof(X)*numberof(XP)
temporary arrays, so the X and Y arrays should be reasonably small.
interpreted function, defined at i/fitrat.i line 72
| |
| SEE ALSO: | fitpol, interp | |
|
fitsAddComment
|
fitsAddComment, header, string
Add STRING as a comment in HEADER (a FitsHeader structure). If
STRING is too long, it is broken in pieces.
interpreted function, defined at i/fits.i line 90
| |
| SEE ALSO: | fitsRead, fitsWrite | |
|
fitsAddHistory
|
fitsAddHistory, header, string
Add STRING as an history card in HEADER (a FitsHeader structure).
If STRING is too long, it is broken in pieces.
Keyword STAMP may be used with a zero value to avoid the
additional time stamp (default is to add a time stamp).
interpreted function, defined at i/fits.i line 106
| |
| SEE ALSO: | fitsRead, fitsWrite | |
|
fitsFixHeader
|
fitsFixHeader, header
check consistency of FITS header.
interpreted function, defined at i/fits.i line 74
| |
| SEE ALSO: | fitsRead, fitsWrite | |
|
fitsHeader
|
header= fitsHeader();
fitsHeader, header;
creates a structure FitsHeader with defaults. Equivalent to:
header= FitsHeader(bscale= 1., bzero= 0.);
interpreted function, defined at i/fits.i line 62
| |
| SEE ALSO: | fitsRead, fitsWrite | |
|
fitsRead
|
a= fitsRead(filename, header)
returns the data of the FITS file FILENAME. If present, the
optional argument HEADER will be used to store the contents of
the FITS header file (a FitsHeader structure).
Keyword WHICH may be used to indicate which sub-array should be
returned. For instance, if the array DATA with dimensions
(235,453,7) is stored in the FITS file "data.fits", the sub-array
DATA(,,4) can be read by:
SUB_DATA= fitsRead("data.fits", which= 4);
Keyword PACK, if non-nil and non-zero, indicates that axis whith
unit dimension should be ignored. The default is to ignore only
zero length axis.
Keyword RESCALE, if non-nil and zero, indicates that read data
values should not be rescaled according to FITS keywords
BSCALE and BZERO. The default is to rescale data values if
BSCALE is not 1. or BZERO is not 0.
interpreted function, defined at i/fits.i line 411
| |
| SEE ALSO: | fitsWrite, fitsRescale | |
|
fitsRescale
|
rescaled_data= fitsRescale(data, bitpix, bscale, bzero)
Linearly rescale the values of input array DATA to fit into
integers with BITPIX bits per value (i.e., `char', `short' or
`long' for BITPIX being 8, 16 and 32 respectively).
Arguments BSCALE and BZERO are optional and purely outputs passed
by address. Their value will be set so that:
DATA(i) = BZERO + BSCALE * RESCALED_DATA(i)
where the equality may not be exact due to rounding errors. The
difference is however the smallest possible, i.e., less than
BSCALE / 2.
Keywords DATA_MIN and DATA_MAX may be used to supply the maximum
and minimum data values or to set brightness cutoffs.
interpreted function, defined at i/fits.i line 137
| |
| SEE ALSO: | fitsRead, fitsWrite | |
|
fitsWrite
|
fitsWrite, filename, data, header
Write DATA in file FILENAME using FITS format. If present, the
information of the optional argument HEADER (a FitsHeader structure)
will be used to write the FITS file header.
Keyword PACK, if non-nil and non-zero, indicates that axis whith
unit dimension should be ignored. The default is to ignore only
zero length axis.
Keyword RESCALE, if non-nil and zero, indicates that input data
values should not be rescaled into integers according to FITS
standard. The default, is to recode doubles as 32 bit integers,
floats as 16 bit integers and integers into smallest integers
possible without loss of dynamic range (e.g., an array of long
integers ranging from -31 to +130 will be recoded as chars).
interpreted function, defined at i/fits.i line 197
| |
| SEE ALSO: |
fitsRead,
fitsRescale,
fitsAddHistory,
fitsAddComment |
|
|
float_neq
|
float_neq interpreted function, defined at i/testb.i line 874 | |
|
floor
|
floor(x)
returns the largest integer not greater than x (no-op on integers).
builtin function, documented at i0/std.i line 624
| |
| SEE ALSO: | ceil | |
|
fma
|
fma
frame advance the current graphics window. The current picture
remains displayed in the associated X window until the next element
is actually plotted.
builtin function, documented at i0/graph.i line 197
| |
| SEE ALSO: | window, hcp, animate, plg | |
|
form_mesh
|
form_mesh(zsym, khold, lhold)
returns an opaque "mesh" object, which will hold rt, zt, ireg,
and a boundary edge list. This opaque mesh object is required
as an input to the integ_flat and integ_linear routines.
ZSYM is 2 for spherical symmetry, 1 for z=0 reflection symmetry,
or 0 for no symmetry
KHOLD and LHOLD are the 1-origin indices of "hold" lines in the
mesh, or 0 if none. This information is used only during the
pcen_source operation before integ_linear is called.
builtin function, documented at i0/drat.i line 1071
| |
| SEE ALSO: | update_mesh, integ_flat, integ_linear | |
|
form_rays
|
best= form_rays( [x, y, z, theta, phi] )
or dirt= form_rays( [x, y, theta] )
or internal= form_rays( [cos, sin, y, z, x, r] )
forms 5-by-nrays, 3-by-nrays, or 6-by-nrays ray representation
given individual lists of array coordinates. The [...]
operator builds an nrays-by-5, nrays-by-3, or nrays-by-6
array, which form_rays transposes. The "nrays" may represent
zero or more actual dimensions.
interpreted function, defined at i/rays.i line 27
| |
| SEE ALSO: |
best_rays,
dirt_rays,
internal_rays,
picture_rays |
|