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
            -----    -----      -------
    	[]        [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