all functions - f

 f1  
 
  
interpreted function, defined at contrib/harmonic.i   line 23  

             z = f2z(x)  
 
    convert 2-by-dims float or double X to complex.  
interpreted function, defined at i/idlsave.i   line 289  

             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  

             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  

             fd12(x)  
 
    return Fermi-Dirac integral of order 1/2,  
       fd12(x) = integral[0 to inf]{ dt * t^0.5 / (exp(t-x)+1) }  
    accurate to about 1e-12  
interpreted function, defined at i/fermi.i   line 56  

             fd32(x)  
 
    return Fermi-Dirac integral of order 3/2,  
       fd32(x) = integral[0 to inf]{ dt * t^1.5 / (exp(t-x)+1) }  
    accurate to about 1e-12  
interpreted function, defined at i/fermi.i   line 96  

             fd52(x)  
 
    return Fermi-Dirac integral of order 5/2,  
       fd52(x) = integral[0 to inf]{ dt * t^2.5 / (exp(t-x)+1) }  
    accurate to about 1e-12  
interpreted function, defined at i/fermi.i   line 135  

             fdi12(x, b)  
 
    return incomplete Fermi-Dirac integral of order 1/2,  
       fdi12(x, b) = integral[b to inf]{ dt * t^0.5 / (exp(t-x)+1) }  
    default accuracy to about 1e-10  
interpreted function, defined at i/fermii.i   line 44  

             fdi32(x, b)  
 
    return incomplete Fermi-Dirac integral of order 1/2,  
       fdi32(x, b) = integral[b to inf]{ dt * t^1.5 / (exp(t-x)+1) }  
    default accuracy to about 1e-10  
interpreted function, defined at i/fermii.i   line 70  

             fdi52(x, b)  
 
    return incomplete Fermi-Dirac integral of order 1/2,  
       fdi32(x, b) = integral[b to inf]{ dt * t^2.5 / (exp(t-x)+1) }  
    default accuracy to about 1e-10  
interpreted function, defined at i/fermii.i   line 96  

             fdim12(x, b)  
 
    return incomplete Fermi-Dirac integral of order -1/2,  
       fdim12(x, b) = integral[b to inf]{ dt * t^-0.5 / (exp(t-x)+1) }  
    default accuracy to about 1e-10  
interpreted function, defined at i/fermii.i   line 18  

             fdm12(x)  
 
    return Fermi-Dirac integral of order -1/2,  
       fdm12(x) = integral[0 to inf]{ dt * t^-0.5 / (exp(t-x)+1) }  
    accurate to about 1e-12  
interpreted function, defined at i/fermi.i   line 15  

             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 1335  

             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  

             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  
 
  
interpreted function, defined at i0/fft.i   line 192  

             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(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%.  

             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%.  

 fft_index  
 
  
interpreted function, defined at contrib/randfield.i   line 243  

             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, 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  

 fft_raw  
 
  
builtin function, documented at i0/fft.i   line 246  

             fft_roll, a rolls values of a    
 
interpreted function, defined at contrib/randfield.i   line 253  

             fft_sec3, a;  
 
     Plot 3-D FFT array A as an set of images, taking care of "rolling" A and  
     setting correct world boundaries.  Keyword SCALE can be used to indicate the  
     "frequel" scale along both axis (SCALE is a scalar) or along each axis  
     (SCALE is a 2-element vector: SCALE=[XSCALE,YSCALE]); by default,  
     SCALE=[1.0, 1.0].  
   KEYWORDS legend, hide, top, cmin, cmax.  
interpreted function, defined at contrib/randfield.i   line 277  

             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  

 fft_test  
 
  
interpreted function, defined at i/testm.i   line 53  

             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  

             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  

             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  

             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  

             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  

             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  

             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  

             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  

 fil_normalize  
 
  
interpreted function, defined at i/filter.i   line 473  

             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(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  

             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  

             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 1093  

 find_file  
 
  
interpreted function, defined at i/make.i   line 574  

              
 
     Parameters:  
       A(1) = peak intensity of spike  
       A(2) = FWHM of spike  
       A(3) = abscissa of spike  
       A(4) = ordinate of spike  
       A(5) = background level  
       A(6) = background X-slope  
       A(7) = background Y-slope  
     Model:  
       MODEL(X,Y) = A1*P((X-A3)/A2)*P((Y-A4)/A2) + A5 + A6*(X-A3) + A7*(Y-A4)  
     where P(U) is the shape function.  
     SHAPE is the 1-D shape of the spike, it can be "spline" to use a  
     cubic B-spline function, "gauss" to use a gaussian or any user  
     defined routine which has the following prototype:  
       func SHAPE(&p, &dp, u) {gg_fit_2d_spike(data)  
         p = f(u);  
         dp = f'(u);  
       }  
    
     where f(u) is a "bell-shaped" function and f'(u) is  
     its derivative; f(u) should have  
     with the following properties:  
       f(0) = 1  
       f(0.5) = 0.5  
       f(-u) = f(u)                              (i.e. f is symmetric)  
       f(u) >= 0     everywhere  
       f'(u)>0 for u<0, f'(0)=0, f'(u)<0 for u>0 (i.e. f is "bell-shaped")  
     the 3 first properties are needed to properly define the FWHM (Full  
     Half Width at Half Maximum).  
         
     Background:  
       BG = nil/0  no background (BG = 0 everywhere)  
       BG = 1      uniform background  
       BG = 2      BG(x,y) = a() + a()*(x-x0) + a()*(y-y0)  
     Spike:  
     Support: */  
interpreted function, defined at contrib/yeti_fit_2d_spike.i   line 385  

             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  

             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  

             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  

 fitsAddComment  
 

 fitsAddHistory  
 

 fitsFixHeader  
 

 fitsHeader  
 
  

 fitsRead  
 

             a= fitsRead(filename, header)  
 
     *** WARNING: Obsolete fits routine (see fits_read) ***   
     
     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.  

 fitsRescale  
 

 fitsWrite  
 

             fits_bitpix_info(bitpix)  
 
     Return string information about FITS bits-per-pixel value.  
interpreted function, defined at i/fits.i   line 2270  

             fits_bitpix_of(x)  
 
       -or- fits_bitpix_of(x, native=1)  
     Return FITS bits-per-pixel value BITPIX for binary data X which can be  
     an array or a data  type (structure definition).  If keyword NATIVE is  
     true, the routine assumes that  binary data will be read/write to/from  
     FITS file using native machine data representation.  The default is to  
     conform to FITS standard and to  assume that XDR binary format will be  
     used in FITS file.  
interpreted function, defined at i/fits.i   line 2298  

             fits_bitpix_type(bitpix)  
 
     Returns Yorick data type given by FITS bits-per-pixel value BITPIX.  
interpreted function, defined at i/fits.i   line 2284  

             fits_check_bitpix(bitpix)  
 
     Test if FITS bits-per-pixel value BITPIX is valid.  
interpreted function, defined at i/fits.i   line 2260  

             fits_check_file(filename)  
 
       -or- fits_check_file(filename, errmode)  
     Returns 1/0  depending whether FILENAME is  a valid FITS  file or not.  
     If ERRMODE is true (non-nil  and non-zero), unreadable file results in  
     false result otherwise it is  a runtime error.  Note that the checking  
     is very simple: it is sufficient that the first FITS card in the first  
     2880 bytes has keyword "SIMPLE" with logical value 'T' (true).  
interpreted function, defined at i/fits.i   line 548  

             fits_close(fh)  
 
     Closes stream in FITS handle  FH.  The header information stored in FH  
     remain unchanged  (e.g. you can keep  editing the header  in FH).  The  
     returned  value is FH.   Note that  if you  destroy all  references to  
     handle FH, the  associated file (if any) gets  automatically closed by  
     Yorick.  
interpreted function, defined at i/fits.i   line 433  

 fits_coordinate  
 
struct fits_coordinate {  
  long axis, length;  
  string ctype;  
  double crpix, crval, cdelt, crota;  
}  

             fits_create(filename)     
 
     Creates  a new  FITS  file FILENAME  and  returns a  FITS handle  with  
     mandatory cards (i.e. SIMPLE, BITPIX, NAXIS, NAXISn) and some optional  
     cards (i.e. EXTEND, BSCALE and BZERO) already initialized.  
     Keyword  BITPIX can  be  used to  set  FITS "bits-per-pixel"  (default  
     is BITPIX=8, i.e. byte data).  
     Keyword DIMLIST  should be used to  specify the dimension  list of the  
     array data that  is intended to be written in  primary HDU.  The value  
     of DIMLIST is similar to the result returned by dimsof.  
     Keyword EXTEND can  be used to indicate whether  the file may contains  
     FITS extensions.  It is probably a good idea to always use EXTEND=1.  
     Keyword TEMPLATE can be set with  an existing FITS handle to copy some  
     FITS cards  of the template into  the new header.  The  FITS card that  
     are  never  copied   are:  "SIMPLE",  "XTENSION",  "BITPIX",  "NAXIS",  
     "NAXIS#" (with #  an integer), "BSCALE" and "BZERO";  the orther cards  
     get copied.  See keywords BSCALE and BZERO if you specifically want to  
     set these values.  
       
     Keywords BSCALE and BZERO can  be used to specify physical value scale  
     and offset.   See fits_write_array to figure out  how keywords BITPIX,  
     BSCALE and BZERO are used to convert data values into file values.  
     Keywords HISTORY  and COMMENT can be  set to add some  comments in the  
     new handle.  The values of these keywords may be array of strings.  
     Keywords ENCODING and OVERWRITE have the same meaning as in fits_open  
     routine (to see).  
interpreted function, defined at i/fits.i   line 448  

             fits_current_hdu(fh);  
 
     Return number of current Header Data Unit in FITS handle FH.  
interpreted function, defined at i/fits.i   line 726  

             fits_date()  
 
     Returns current Universal Time date as a string conforming to FITS  
     standard: "DD/MM/YY"  
interpreted function, defined at i/fits.i   line 785  

             fits_delete, fh, pattern;  
 
     Delete all cards  matching PATTERN from current header  of FITS handle  
     FH (see fits_match for the syntax of PATTERN).  
interpreted function, defined at i/fits.i   line 2562  

             fits_filename(fh)  
 
     Return path name  of file associated with FITS handle  FH (in fact the  
     argument may also be any Yorick open stream).  
interpreted function, defined at i/fits.i   line 2197  

             fits_get(fh, pattern, comment)  
 
     Get  (array  of)  value(s)   for  FITS  cards  matching  PATTERN  (see  
     fits_match) in current header of FITS handle FH.  If present, argument  
     COMMENT is  an output symbol  where the corresponding comment  part of  
     selected card(s)  will be stored.   In order to avoid  namespace clash  
     due to Yorick's  scoping rules, COMMENT should be  declared as a local  
     symbol in the calling function, e.g.:  
       local comment;  
       value = fits_get(fh, pattern, comment);  
     If no  cards match PATTERN, the  value of keyword  DEFAULT is returned  
     and COMMENT is set to the null string.  
     If multiple  cards match PATTERN, they  must have the  same value type  
     unless keyword PROMOTE is true, in which case the routine promotes all  
     card values to a suitable "highest" type.  
     Request fo commentary cards  (i.e. PATTERN is "HISTORY", "COMMENT", or  
     "") may returns several cards.  
interpreted function, defined at i/fits.i   line 2439  

             fits_get_bitpix(fh)  
 
       -or- fits_get_bitpix(fh, fix)  
     Get  BITPIX   value  from  current   HDU  in  FITS  handle   FH.   See  
     fits_get_special for the meaning of FIX.  
interpreted function, defined at i/fits.i   line 792  

             fits_get_bscale(fh)  
 
       -or- fits_get_bzero(fh)  
     Get BSCALE and BZERO values  for FITS handle FH.  These parameters are  
     used to convert file values into physical values according to:  
         physical_value = BZERO + BSCALE * file_value  
     if the corresponding card is  missing, BSCALE and BZERO default to 1.0  
     and 0.0 respectively.  
interpreted function, defined at i/fits.i   line 2682  

             fits_get_cards(fh, pattern);  
 
     Return cards from  FITS handle FH which match  PATTERN (see fits_match  
     for the syntax of PATTERN).  
interpreted function, defined at i/fits.i   line 2550  

             fits_get_data_size(fh)  
 
       -or- fits_get_data_size(fh, fix)  
     Computes  the number  of bytes  in data  part of  current HDU  of FITS  
     handle FH.  This value is computed  according to the header part of FH  
     and may be different from the  number of bytes actually written in the  
     data part of the current HDU.  
interpreted function, defined at i/fits.i   line 1078  

             fits_get_dims(fh)  
 
       -or- fits_get_dims(fh, fix)  
     Get all  NAXIS* values from current  HDU in FITS handle  FH and return  
     vector  [NAXIS, NAXIS1,  NAXIS2, ...].   If the  value of  any  of the  
     "NAXIS#" card is  zero, then there is no data in  the current unit and  
     fits_get_dims returns [] (nil) in this case.  See fits_get_special for  
     the meaning of FIX.  
interpreted function, defined at i/fits.i   line 820  

             fits_get_gcount(fh)  
 
       -or- fits_get_pcount(fh)  
     Get PCOUNT and  GCOUNT values for FITS handle FH.   PCOUNT shall be an  
     integer  equal  to  the  number  of parameters  preceding  each  group  
     (default value 0).  GCOUNT shall be  an integer equal to the number of  
     random groups present (default value  1).  The total number of bits in  
     the data  array (exclusive of  fill that is  needed after the  data to  
     complete the last record) is given by the following expression:  
         NBITS = abs(BITPIX)*GCOUNT*(PCOUNT + NAXIS1*NAXIS2*...*NAXISm)  
interpreted function, defined at i/fits.i   line 2700  

             fits_get_history(fh)  
 
       -or- fits_get_comment(fh)  
     Get COMMENT and  HISTORY values for FITS handle FH.   The result is an  
     array of string(s) or nil if no such cards exists in the header of the  
     current unit.  
interpreted function, defined at i/fits.i   line 2723  

             fits_get_keywords(fh)  
 
       -or- fits_get_keywords(fh, ordered)  
     Get list  of FITS keywords defined  in current HDU of  FITS handle HF.  
     The returned value is an array of strings. If ORDERED is true (non-nil  
     and non-zero),  the keywords get  sorted.  Note: the "END"  keyword is  
     always missing in a (non-corrupted) FITS handle.  
interpreted function, defined at i/fits.i   line 954  

             fits_get_naxis(fh)  
 
       -or- fits_get_naxis(fh, fix)  
     Get  NAXIS   value  from   current  HDU  in   FITS  handle   FH.   See  
     fits_get_special for the meaning of FIX.  
interpreted function, defined at i/fits.i   line 807  

             fits_get_special(fh, key, id, location, fix)  
 
     Get  value of  a special  FITS card  given its  key  string, numerical  
     identifier and absolute  LOCATION (1 for first FITS  card).  If FIX is  
     true,  various further  verifications  are made  and,  if FITS  strict  
     checking mode is  off, the header may be fixed  in case of unambiguous  
     error.  
interpreted function, defined at i/fits.i   line 869  

             fits_get_xtension(fh)  
 
     Get XTENSION value  from current HDU in FITS  handle FH.  The returned  
     value is a  scalar string with the name of  the extension;  "IMAGE" is  
     returned for the primary HDU.  
interpreted function, defined at i/fits.i   line 845  

             fits_goto_hdu(fh, hdu)  
 
     Move FITS handle FH to Header  Data Unit number HDU (starting at 1 for  
     the primary HDU) and parse the  header part of the new unit.  Contents  
     of FH  is updated with  header part of  new HDU.  To allow  for linked  
     calls, the returned value is FH.  
interpreted function, defined at i/fits.i   line 673  

 fits_id  
 
interpreted function, defined at i/fits.i   line 2577  

             fits_id(card)  
 
       -or- fits_ids(cards)  
     Convert  FITS  card(s) or  FITS  card  name(s)  into unique  numerical  
     indentifier.  CARD  is a  scalar string  and CARDS (with  an S)  is an  
     array  of  string(s) (including  a  scalar).   Only  the keyword  part  
     (characters  1:8)  of  CARD(S)  is  relevant;  cards  shorter  than  8  
     characters yield  the same  identifier as if  they were  padded (right  
     filled) with spaces.   In other words, all the  values returned by the  
     following expressions are identical:  
       fits_id("SIMPLE = T / conforming FITS file");  
       fits_id("SIMPLE ");  
       fits_id("SIMPLE");  
interpreted function, defined at i/fits.i   line 2577  

             fits_init;  
 
     (Re)initializes FITS private  data.  Normally you do not  have to call  
     this  routine  because  this  routine  is  automatically  called  when  
     "fits2.i" is  parsed by Yorick.   You may however need  to explicitely  
     call  fits_init  if  you  suspect  that some  FITS  private  data  get  
     corrupted or if you want to tune FITS strict/sloopy behaviour.  
     If keyword SLOOPY  is true (non-nil and non-zero)  some discrepancy is  
     allowed (for reading FITS file only); otherwise strict FITS compliance  
     is applied.  If SLOOPY is true, lower case Latin letters have the same  
     meaning  as their  upper  case counterparts,  most control  characters  
     become identical to regular spaces.  
     According to FITS standard, the only characters permitted for keywords  
     are  upper  case  (capital)  Latin alphabetic,  numbers,  hyphen,  and  
     underscore.  Leading and embedded blanks are forbidden.  If you cannot  
     read a FITS file because it does not confrom to this rule, you can use  
     keyword ALLOW (a string or an array of characters) to allow additional  
     characters for FITS keywords.  For instance:  
       fits_init, allow="/."; // fix for invalid headers made by IRAF  
     make characters '/'  and '.'  acceptable in FITS  keywords.  Note that  
     you  must apply fits_rehash  (to see)  to _every_  FITS handle  in use  
     whenever you change  the set of allowed characters  (because this will  
     probably corrupt the values of numerical identifiers of FITS card) ...  
     It is  therefore a good idea  to change the set  of allowed characters  
     before using any FITS routines.  
     Keyword  BLANK can  be  used to  add  more characters  that should  be  
     considered as blanks (spaces)  when parsing FITS header/keywords.  The  
     value  of BLANK  must  be a  string  or an  array  of characters,  for  
     instance: BLANK="\t\r\v\n".  Note that this break strict compliance to  
     FITS standard.  
interpreted function, defined at i/fits.i   line 2793  

             fits_is_integer(x)  
 
     Returns true if array X is of integer type.  
interpreted function, defined at i/fits.i   line 2166  

             fits_is_integer_scalar(x)  
 
     Returns true if array X is a scalar of integer type.  
interpreted function, defined at i/fits.i   line 2173  

             fits_is_real_scalar(x)  
 
     Returns true if array X if of real type (i.e. double or float).  
interpreted function, defined at i/fits.i   line 2183  

             fits_is_scalar(x)  
 
     Returns true if X is a scalar.  
interpreted function, defined at i/fits.i   line 2159  

             fits_is_string_scalar(x)  
 
     Returns true if array X is a scalar of string type.  
interpreted function, defined at i/fits.i   line 2190  

             fits_key(id)  
 
     Convert  (array   of)  FITS   numerical  identifier(s)  ID   into  the  
     corresponding string FITS keyword(s) without trailing spaces.  
interpreted function, defined at i/fits.i   line 2641  

             fits_list, fh;  
 
       -or- fits_list(fh)  
     Get the names of  the FITS extensions in FH.  FH can  be the name of a  
     FITS file  or a FITS handle  FH (the input handle  is left unchanged).  
     When called  as a  subroutine, the list  is printed to  terminal; when  
     called as  a function, the returned  value is a string  array with the  
     names of the FITS extensions in FH.  
interpreted function, defined at i/fits.i   line 732  

             fits_map(op, src)  
 
     Map scalar function OP onto array argument SRC to mimics element-wise  
     unary operation.  
interpreted function, defined at i/fits.i   line 2144  

             fits_move, a, i, j;  
 
     Move I-th element of array A  in place of J-th element.  The operation  
     is done in-place.  
interpreted function, defined at i/fits.i   line 984  

             fits_move_card(fh, from, to);  
 
     Change location of FROM-th card to  index TO into FITS handle FH.  The  
     operation is made in place.  
interpreted function, defined at i/fits.i   line 973  

             fits_new_bintable(fh)  
 
       -or- fits_new_bintable(fh, comment)  
         
     Starts a new  binary table FITS extension.  This  routine starts a new  
     FITS extension with  name "BINTABLE" and pre-set FITS  cards needed to  
     describe the  table with fake values  (the correct values  will be set  
     when  fits_write_bintable  is called  to  actually  write the  table).  
     After calling this  routine, the user can add new  FITS cards (but not  
     XTENSION,  BITPIX,   NAXIS,  NAXIS1,  NAXIS2,   GCOUNT,  nor  PCOUNT).  
     Optional argument COMMENT is the comment string for the XTENSION card.  
     The returned value is FH.  
interpreted function, defined at i/fits.i   line 1713  

             fits_new_hdu(fh, xtension)  
 
       -or- fits_new_hdu(fh, xtension, comment)         
     Starts a new extension in FITS  file open for writing.  FH is the FITS  
     handle, XTENSION is  the name of the FITS extension  and COMMENT is an  
     optional string comment.  After calling fits_new_hdu, there is no need  
     to call:  
       fits_set, FH, "XTENSION", XTENSION, COMMENT;  
     since this is already done by this routine.  However, beware that FITS  
     standard requires that, if any  extension is present in the file, that  
     the keyword "EXTEND" with logical  value 'T' (true) must appear in the  
     primary header.  
interpreted function, defined at i/fits.i   line 1104  

             fits_new_image(fh, ...)  
 
     Starts a new image (array)  FITS extension.  This routine starts a new  
     FITS  extension with  name "IMAGE"  and pre-set  FITS cards  needed to  
     describe the array data according to keywords: BITPIX, DIMLIST, BZERO,  
     BSCALE.  The returned value is FH.  
       
interpreted function, defined at i/fits.i   line 1690  

             fits_next_hdu(fh)  
 
     Move FITS handle FH to next Header Data Unit and parse the header part  
     of the  new unit.  Contents of FH  is updated with header  part of new  
     HDU.  To allow for linked calls, the returned value is FH.  
interpreted function, defined at i/fits.i   line 696  

             fits_nth(n)  
 
     Returns a string in the form "1st", "2nd", "3rd" or "#th" where # is  
     the human readable value of integer N.  
interpreted function, defined at i/fits.i   line 772  

             fits_open(filename)  
 
       -or- fits_open(filename, filemode)  
     Opens  the FITS  file FILENAME  according to  FILEMODE.   The returned  
     value is a FITS handle used  in most other FITS routines.  FILEMODE is  
     one of:  
       "r" or 'r' - read mode,  the header of the primary  HDU get read and  
                    is parsed.  
       "w" or 'w' - write   mode,  new  file  is  created  (unless  keyword  
                    OVERWRITE is true, FILENAME must not already exists).  
       "a" or 'a' - append  mode, stream  get positionned  at last HDU, the  
                    header of the last HDU get read and parsed.  
     The default FILEMODE is "r" -- open an existing FITS file for reading.  
     Keyword ENCODING can  be used to change the data  encoding of the FITS  
     file which is  "xdr" for a regular FITS file  (XDR means eXternal Data  
     Representation,  which is  natively  used by  all  IEEE compliant  big  
     endian machine).  The value of the keyword is a string like:  
       "xdr", "sun"    - eXternal Data Representation (the default)  
       "native"        - native data representation (i.e. no conversion)  
       "i86", "pc"     - IEEE little endian machines  
       ...  
     see documentation for "__sun" for  a list of supported encodings. Note  
     that  using  an encoding  different  from  IEEE  big endian  (or  XDR)  
     violates FITS standard.  
     Keyword OVERWRITE can be used to force overwriting of an existing file  
     (otherwise it is an error to create a file that already exists).  
interpreted function, defined at i/fits.i   line 368  

             fits_read(filename)  
 
       -or- local fh; a = fits_read(filename, fh)  
     Open  FITS file  FILENAME and  read data.   FH is  an  optional output  
     symbol where  the FITS handle  will be stored  for future use  such as  
     moving  to  a  FITS  extension  in  the  same  file  and  reading  its  
     header/data.  (Note:  a FITS handle is  a Yorick list  that contains a  
     file handle and all header information from the current HDU.)  
     By  default, the data  get read  from the  first HDU  but this  can be  
     changed with the HDU keyword (default HDU=1, i.e. primary HDU).  
     Keyword ENCODING can be used and  has the same meaning as in fits_open  
     (to see).  
     Keywords WHICH and RESCALE can be used and have the same meaning as in  
     fits_read_array (to see).   These keywords are ignored if  HDU to read  
     is not primary HDU nor an "image" extension.  
interpreted function, defined at i/fits.i   line 300  

             fits_read_array(fh)  
 
     Gets "image" (actually a Yorick array) from current HDU of FITS handle  
     FH.  Note that the result may be [] (nil) if the current unit contains  
     no data.  
     Keyword  WHICH may  be  used  to indicate  which  sub-array should  be  
     returned.  WHICH always  applies to the last dimension  of the "image"  
     data  stored in current  HDU.  For  instance, if  the array  DATA with  
     dimensions  (235,453,7)  is  stored  in  the  current  FITS  HDU,  the  
     sub-array DATA(,,4) can be obtained by:  
         fits_read_array(FH, which=4);  
     If keyword RESCALE is true,  returned values get rescaled according to  
     FITS keywords BSCALE and BZERO.  If RESCALE=2 and one of BSCALE and/or  
     BZERO exists in  the FITS header and  BITPIX was 8, 16, 32,  or -32, a  
     single precision  array (float)  is returned.  If  RESCALE is  not set  
     (nil), the  default is to  rescale data values  if BSCALE is not  1 or  
     BZERO is not  0 (i.e. the default is RESCALE=1).  In  order to get raw  
     data (i.e. as written in the file), use RESCALE=0.  
interpreted function, defined at i/fits.i   line 1447  

             fits_read_bintable(fh)  
 
     Reads a binary table in current  HDU of FITS handle FH and returns the  
     fields of  the table as  a pointer array  (i-th field of the  table is  
     pointed  by  i-th  pointer  element).   Empty fields  and  fields  for  
     unsupported data  types (bit array  and array descriptor) result  in a  
     null pointer (&[]).  The geometry  of the arrays pointed by the result  
     will be  NCOLS(i) by NROWS  where NROWS is  the number of rows  in the  
     table and NCOLS(i) is the repeat  count of the i-th field in the table  
     (see fits_write_bintable).  
interpreted function, defined at i/fits.i   line 1903  

             fits_read_header(fh)  
 
     (Re)read  and parse  header of  current  HDU of  FITS handle  FH.  
     Contents of FH is updated with  header part of new HDU.  To allow  
     for linked calls,  the returned value is FH.   If the current HDU  
     is empty (i.e. last HDU in the file), the header will be empty.  
interpreted function, defined at i/fits.i   line 572  

             fits_rehash(fh);  
 
     (Re)compute array of numerical identifier for FITS handle FH (operation  
     is done in-place) and return FH.  
interpreted function, defined at i/fits.i   line 2669  

             fits_rewind(fh)  
 
     Move FITS handle FH to primary Header Data Unit and parse the header part  
     of the unit.  FH is returned when called as a function.  
interpreted function, defined at i/fits.i   line 711  

             fits_set, fh, key, value;  
 
       -or- fits_set, fh, key, value, comment;  
     Set (or adds) FITS card in header  of FITS handle FH.  KEY is the card  
     name (FITS keyword)  and must be a scalar string,  VALUE is the scalar  
     value of the card and COMMENT is an optional string comment.  
     Commentary cards -- for which KEY  is one of "COMMENT, "HISTORY" or ""  
     (blank) -- get appended to the  existing cards in the header of FH (if  
     the VALUE of a commentary card is too long, it may occupy several FITS  
     cards).   For any  other  kind of  cards,  the new  card replaces  the  
     existing one, if any; or  get appended to the existing cards.  Special  
     cards that must appear in a precise order ("SIMPLE", "BITPIX", "NAXIS"  
     and "NAXIS#") must  be added in the correct order  (their value can be  
     modified afterward).  The "END"  card is not  needed since it  will be  
     automatically written when required.  
interpreted function, defined at i/fits.i   line 1153  

             fits_set_dims(fh, dimlist)  
 
      Set NAXIS  and NAXIS1,  NAXIS2, ... values  into current HDU  of FITS  
      handle FH according to dimension list DIMLIST.  DIMLIST may be empty.  
interpreted function, defined at i/fits.i   line 1660  

             fits_tolower(s)  
 
       -or- fits_toupper(s)  
     Converts a string or an array of strings S to lower/upper case letters.  
interpreted function, defined at i/fits.i   line 2118  

 fits_toupper  
 
interpreted function, defined at i/fits.i   line 2118  

             fits_trim(s)  
 
     Removes trailing  spaces (character 0x20) from scalar  string S (note:  
     trailing spaces are not significant in FITS).  
interpreted function, defined at i/fits.i   line 2132  

             fits_write, filename, data;  
 
       -or- fits_write(filename, data)  
     Creates a new FITS file FILENAME  and write array DATA in primary HDU.  
     When called  as a function,  the result is  a FITS handle that  can be  
     used to append extensions to the file.  
     FITS "bits-per-pixel"  can be specified by  keyword BITPIX; otherwise,  
     BITPIX   is   automatically   guessed   from  the   data   type   (see  
     fits_bitpix_of).  
     Keywords  EXTEND, TEMPLATE, HISTORY  COMMENT, BSCALE,  BZERO, ENCODING  
     and OVERWRITE have the same meaning as in fits_create (to see).  
interpreted function, defined at i/fits.i   line 335  

             fits_write_array, fh, data;  
 
     Write  array DATA  into  curent HDU  of  FITS handle  FH.   DATA is  a  
     so-called "image"  in FITS jargon but  it can be a  numerical array of  
     any-dimension.   FITS cards BITPIX,  BSCALE and  BZERO are  taken into  
     account to convert data values into file values.  The file values are:  
         (DATA  - BZERO)/BSCALE  
     with BZERO=0 and  BSCALE=1 by default (i.e. if not found  in FH) or if  
     keyword RESCALE  is explicitely set  to zero.  The values  are further  
     subject to rounding  to the nearest integer and  clipping for positive  
     BITPIX.  If  keyword RESCALE is  explicitely set to false  (zero), the  
     file values get written without BSCALE/BZERO scale conversion.  
     The N dimensions of DATA must  match the values of the NAXIS1, NAXIS2,  
     ..., NAXISn  cards of  the FITS  file (it is  assumed that  the header  
     information  stored in  FH  are synchronized  to  the header  actually  
     written) extra dimensions in the  FITS file are considered as possible  
     data slices.  By  default, the first data slice  get written.  Keyword  
     WHICH may be used to write a given slice of data.  The value WHICH may  
     be less or equal zero to choose  a slice with respect to the last one.  
  EXAMPLE:  
     The following  example creates a FITS file  with a 100-by-45-by-4-by-7  
     "image" data made of random  values computed and written one 100-by-45  
     slice at a time:  
       fh = fits_create("newfile.fits", bitpix=16, dimlist=[4,100,45,4,7],  
                        bscale=1e-4, bzero=0.0);  
       fits_write_header, fh;  
       nslices = 4*7; // product of last FITS dimensions  
       for (i=1 ; i<=nslices ; ++i)  
         fits_write_array, fh, random(100, 45), which=i;  
       fits_close, fh;  
                          
interpreted function, defined at i/fits.i   line 1524  

             fits_write_bintable(fh, ptr)  
 
     Writes contents  of pointer PTR in  a binary table in  FITS handle FH.  
     Arrays pointed  by PTR  become the  fields of the  table (in  the same  
     order as in  PTR) and must all have 2 dimensions  with the same second  
     dimension (i.e. the number of rows in the table), first dimensions can  
     have any values  and may all be different. In other words:  
       *PTR(i) = i-th field in  the table, is an NCOLS(i)ŚNROWS array where  
                 NROWS is the  number of rows in the  table and NCOLS(i) is  
                 the repeat count of the i-th field.  
       
     In the current  version of the routine, only  arrays of numbers (char,  
     short, int,  long, float,  double or complex)  and vectors  of strings  
     (you  can  use several  vectors  to  circumvent  this limitation)  are  
     supported.  Before writing  the data part of a  binary table, you must  
     creates proper header:  
        fits_new_bintable, fh;        // starts a new binary table  
        fits_set, fh, "...", ...;     // (optional) set more info. in header  
        fits_set, ...;  
        fits_write_bintable, fh, ptr; // write binary table  
     fits_write_bintable automatically  guess the  format of the  fields in  
     the binary table and accordingly set FITS cards "TFORM#" (with # equal  
     to the field number) in the header of the binary table.  
     If keyword LOGICAL is true (non nil and non-zero) then arrays of int's  
     in  PTR  are considered  as  logical arrays  and  saved  as arrays  of  
     characters: 'F' for false, 'T' for true or '\0' for bad/invalid value.  
     Following Yorick's convention, a "false"  value is integer zero in the  
     arrays of  int's and  a "true" is  any non-zero integer.   However, if  
     LOGICAL has the  special value 2, then strictly  positive integers are  
     treated as "true" values and strictly negative integers are treated as  
     invlaid  values.  Note  that this  only  affect arrays  of int's  (not  
     long's  nor short's nor  char's).  The  default is  to save  arrays of  
     int's as array of 32 bits integers.  
     The returned value is FH.  
interpreted function, defined at i/fits.i   line 1736  

             fits_write_header(fh)  
 
     Write  header  information of  FITS  handle  FH  into current  HDU  of  
     associated file.   It is possible to  re-write header as  long as this  
     would not overwrite existing written data if any (i.e. the new header,  
     rounded up  to a multiple of 2880  bytes, must not be  longer than the  
     old one or there must be no data written.  
interpreted function, defined at i/fits.i   line 1007  

 float_neq  
 
  
interpreted function, defined at i/testb.i   line 874  

             floor(x)  
 
     returns the largest integer not greater than x (no-op on integers).  
builtin function, documented at i0/std.i   line 668  

             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 254  

             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 1069  

             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  

             compute 4 pt correlation function in 1D  
 
   flag pp = defines the number of pts over which to average   
   EXAMPLE   
   #include "randfield.i"  
   ui=genrandfield1D(20); u=fft(ui,[-1]).re;  
   res =fourptcor1D(u)  
       
interpreted function, defined at contrib/correl.i   line 896