  GNU-Darwin Web
section f of routines in global.i Home

Manual

Packages

Global Index

Keywords

Quick Reference

# 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 ----- ----- ------- []  forward transform last dimension of X  [] 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